From e591e54c0b56bd599e286fe46723bdb36b608c79 Mon Sep 17 00:00:00 2001
From: Oriol Arcas <oriol.arcas@huawei-partners.com>
Date: Mon, 16 Dec 2024 10:57:51 +0000
Subject: [PATCH 01/64] Start logging before loading config

Signed-off-by: Oriol Arcas <oriol.arcas@huawei-partners.com>
---
 orion-proxy/src/lib.rs | 156 ++++++++++++++++++++++++++++++++---------
 1 file changed, 123 insertions(+), 33 deletions(-)

diff --git a/orion-proxy/src/lib.rs b/orion-proxy/src/lib.rs
index 565a4252..f9051244 100644
--- a/orion-proxy/src/lib.rs
+++ b/orion-proxy/src/lib.rs
@@ -18,13 +18,8 @@
 //
 //
 
-use orion_configuration::{
-    config::{Config, Log as LogConf},
-    options::Options,
-};
+use orion_configuration::{config::Config, options::Options};
 use orion_lib::{Result, RUNTIME_CONFIG};
-use tracing_appender::non_blocking::WorkerGuard;
-use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Registry};
 
 #[macro_use]
 mod core_affinity;
@@ -33,37 +28,104 @@ mod runtime;
 mod xds_configurator;
 
 pub fn run() -> Result<()> {
+    let mut tracing_manager = proxy_tracing::TracingManager::new();
+
     let options = Options::parse_options();
     let Config { runtime, logging, bootstrap } = Config::new(&options)?;
     RUNTIME_CONFIG.set(runtime).map_err(|_| "runtime config was somehow set before we had a chance to set it")?;
-    let _guard = init_tracing(logging);
+
+    tracing_manager.update(logging)?;
+
     #[cfg(target_os = "linux")]
     if !(caps::has_cap(None, caps::CapSet::Permitted, caps::Capability::CAP_NET_RAW)?) {
         tracing::warn!("CAP_NET_RAW is NOT available, SO_BINDTODEVICE will not work");
     }
+
     proxy::run_proxy(bootstrap)
 }
 
-#[cfg(feature = "console")]
-use console_subscriber;
+#[cfg(not(feature = "console"))]
+mod proxy_tracing {
+    use tracing_appender::non_blocking::{NonBlocking, WorkerGuard};
+    use tracing_subscriber::fmt::format::{DefaultFields, Format};
+    use tracing_subscriber::layer::Layered;
+    use tracing_subscriber::{fmt, reload};
+    use tracing_subscriber::{reload::Handle, EnvFilter, Registry};
 
-#[cfg(feature = "console")]
-fn init_tracing(_conf: LogConf) -> WorkerGuard {
-    let (_non_blocking, guard) = tracing_appender::non_blocking(std::io::stdout());
-    console_subscriber::init();
-    guard
-}
+    use orion_configuration::config::Log as LogConf;
+    use orion_lib::Result;
 
-#[cfg(not(feature = "console"))]
-fn init_tracing(log_conf: LogConf) -> WorkerGuard {
-    let env_filter = EnvFilter::try_from_default_env().ok().or(log_conf.log_level).unwrap_or_else(|| {
-        EnvFilter::builder()
-            .with_default_directive(tracing_subscriber::filter::LevelFilter::ERROR.into())
-            .parse_lossy("")
-    });
-
-    match log_conf.log_file.as_ref() {
-        None => {
+    type RegistryLayer =
+        fmt::Layer<Layered<reload::Layer<EnvFilter, Registry>, Registry>, DefaultFields, Format, NonBlocking>;
+    type FilterReloadHandle = Handle<EnvFilter, Registry>;
+    type LayerReloadHandle = Handle<
+        fmt::Layer<Layered<reload::Layer<EnvFilter, Registry>, Registry>, DefaultFields, Format, NonBlocking>,
+        Layered<reload::Layer<EnvFilter, Registry>, Registry>,
+    >;
+
+    pub struct TracingManager {
+        guard: WorkerGuard,
+        layer_reload_handle: LayerReloadHandle,
+        filter_reload_handle: FilterReloadHandle,
+    }
+
+    impl TracingManager {
+        pub fn new() -> Self {
+            let level = EnvFilter::builder()
+                .with_default_directive(tracing_subscriber::filter::LevelFilter::INFO.into())
+                .parse_lossy("");
+            let (guard, layer_reload_handle, filter_reload_handle) = Self::init_tracing(Registry::default(), level);
+            TracingManager { guard, filter_reload_handle, layer_reload_handle }
+        }
+
+        pub fn update(&mut self, log_conf: LogConf) -> Result<()> {
+            // Update log level
+            self.filter_reload_handle.modify(|filter| {
+                *filter = EnvFilter::try_from_default_env().ok().or(log_conf.log_level).unwrap_or_else(|| {
+                    EnvFilter::builder()
+                        .with_default_directive(tracing_subscriber::filter::LevelFilter::ERROR.into())
+                        .parse_lossy("")
+                });
+            })?;
+
+            // Update tracing layer if necessary (stdout -> file)
+            if let Some(log_file) = log_conf.log_file {
+                self.layer_reload_handle.modify(|layer| {
+                    let (new_guard, new_layer) = Self::file_layer(&log_file, log_conf.log_directory);
+                    *layer = new_layer;
+                    self.guard = new_guard;
+                })?;
+            }
+
+            Ok(())
+        }
+
+        #[cfg(not(feature = "console"))]
+        fn init_tracing(
+            registry: Registry,
+            log_level: EnvFilter,
+        ) -> (WorkerGuard, LayerReloadHandle, FilterReloadHandle) {
+            use tracing_subscriber::layer::SubscriberExt as _;
+            use tracing_subscriber::util::SubscriberInitExt as _;
+
+            let env_filter = EnvFilter::try_from_default_env().ok().or(Some(log_level)).unwrap_or_else(|| {
+                EnvFilter::builder()
+                    .with_default_directive(tracing_subscriber::filter::LevelFilter::ERROR.into())
+                    .parse_lossy("")
+            });
+
+            // Start as an stdout layer by default, after reading the configuration this can be upgraded to a file layer
+            let (guard, layer) = Self::stdout_layer();
+            let (layer, layer_reload_handle) = reload::Layer::new(layer);
+
+            let (env_filter, filter_reload_handle) = reload::Layer::new(env_filter);
+
+            registry.with(env_filter).with(layer).init();
+            (guard, layer_reload_handle, filter_reload_handle)
+        }
+
+        #[cfg(not(feature = "console"))]
+        fn stdout_layer() -> (WorkerGuard, RegistryLayer) {
             let out = std::io::stdout();
             let is_terminal = std::io::IsTerminal::is_terminal(&out);
             let (non_blocking, guard) = tracing_appender::non_blocking(out);
@@ -73,16 +135,44 @@ fn init_tracing(log_conf: LogConf) -> WorkerGuard {
                 std_layer = std_layer.with_ansi(false);
             }
 
-            Registry::default().with(env_filter).with(std_layer).init();
-            guard
-        },
-        Some(filename) => {
+            (guard, std_layer)
+        }
+
+        #[cfg(not(feature = "console"))]
+        fn file_layer(filename: &str, log_directory: Option<String>) -> (WorkerGuard, RegistryLayer) {
             let file_appender =
-                tracing_appender::rolling::hourly(log_conf.log_directory.as_ref().unwrap_or(&".".into()), filename);
+                tracing_appender::rolling::hourly(log_directory.as_ref().unwrap_or(&".".into()), filename);
             let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
             let file_layer = fmt::layer().with_ansi(false).with_writer(non_blocking).with_thread_names(true);
-            Registry::default().with(env_filter).with(file_layer).init();
-            guard
-        },
+
+            (guard, file_layer)
+        }
+    }
+}
+
+#[cfg(feature = "console")]
+mod proxy_tracing {
+    #[cfg(feature = "console")]
+    use console_subscriber;
+
+    use tracing_appender::non_blocking::WorkerGuard;
+
+    use orion_configuration::config::Log as LogConf;
+    use orion_lib::Result;
+
+    pub struct TracingManager {
+        _guard: WorkerGuard,
+    }
+
+    impl TracingManager {
+        pub fn new() -> Self {
+            let (_non_blocking, guard) = tracing_appender::non_blocking(std::io::stdout());
+            console_subscriber::init();
+            TracingManager { _guard: guard }
+        }
+
+        pub fn update(&mut self, _log_conf: LogConf) -> Result<()> {
+            Ok(())
+        }
     }
 }

From fd48dc5a28ceb04ee4c371757072759353eb8af0 Mon Sep 17 00:00:00 2001
From: Rui Ferreira <rui.ferreira@huawei.com>
Date: Thu, 6 Mar 2025 22:24:41 +0000
Subject: [PATCH 02/64] Clear backlog of clippy warnings

Signed-off-by: Rui Ferreira <rui.ferreira@huawei.com>
---
 Cargo.toml                                    | 60 ++++++-------------
 clippy.toml                                   |  2 -
 orion-configuration/src/config.rs             | 11 ++--
 orion-configuration/src/config/cluster.rs     |  5 +-
 .../src/config/cluster/health_check.rs        |  4 ++
 .../config/cluster/http_protocol_options.rs   |  6 +-
 orion-configuration/src/config/core.rs        |  6 +-
 orion-configuration/src/config/listener.rs    |  3 +-
 orion-configuration/src/config/log.rs         |  1 +
 .../http_connection_manager.rs                |  6 +-
 .../http_connection_manager/header_matcher.rs |  2 +-
 .../http_connection_manager/route.rs          |  3 +-
 orion-configuration/src/config/runtime.rs     |  1 +
 orion-configuration/src/config/transport.rs   |  1 +
 orion-configuration/src/lib.rs                |  3 +-
 orion-lib/src/body/timeout_body.rs            |  8 ++-
 orion-lib/src/clusters/balancers/least.rs     |  1 +
 orion-lib/src/clusters/balancers/random.rs    |  1 +
 orion-lib/src/clusters/cached_watch.rs        |  2 +-
 .../src/clusters/health/checkers/grpc/mod.rs  |  6 +-
 orion-lib/src/clusters/load_assignment.rs     | 14 ++++-
 orion-lib/src/clusters/retry_policy.rs        |  2 +-
 orion-lib/src/configuration/mod.rs            |  2 +-
 orion-lib/src/lib.rs                          |  1 +
 orion-lib/src/listeners/filterchain.rs        |  2 +-
 .../src/listeners/http_connection_manager.rs  | 11 ++--
 .../http_connection_manager/redirect.rs       |  2 +-
 orion-lib/src/listeners/listener.rs           | 17 +++---
 orion-lib/src/listeners/rate_limiter/mod.rs   | 16 +++--
 .../src/listeners/synthetic_http_response.rs  |  4 +-
 orion-lib/src/secrets/secrets_manager.rs      |  2 +-
 orion-lib/src/transport/bind_device.rs        |  5 +-
 orion-lib/src/transport/http_channel.rs       | 12 ++--
 orion-lib/src/transport/tls_inspector.rs      |  4 +-
 orion-proxy/src/core_affinity.rs              |  1 +
 orion-proxy/src/lib.rs                        |  7 +--
 orion-proxy/src/proxy.rs                      |  4 +-
 orion-proxy/src/xds_configurator.rs           |  2 +-
 orion-proxy/tests/configs.rs                  |  1 +
 orion-xds/Cargo.toml                          | 21 +------
 orion-xds/examples/server_routes_and_loads.rs |  1 +
 orion-xds/src/xds/bindings.rs                 |  1 +
 orion-xds/src/xds/resources/mod.rs            |  2 +-
 43 files changed, 122 insertions(+), 144 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ff844bc1..32601b24 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -74,49 +74,23 @@ debug = 1
 inherits = "release"
 
 [workspace.lints.clippy]
-correctness = { level = "deny", priority = 10 }
-disallowed-methods = "deny"
-expect_used = "warn"                            # FIXME this should be deny
-panic = "warn"                                  # FIXME this should be deny
-todo = "deny"
-transmute_ptr_to_ptr = "deny"
+pedantic = { level = "warn", priority = -1 }
+disallowed-methods      = "deny"
+expect_used             = "warn" # FIXME this should be deny
+correctness             = { level = "deny", priority = 10 }
+panic			= "warn" # FIXME this should be deny
+todo                    = "deny"
+transmute_ptr_to_ptr    = "deny"
 unchecked_duration_subtraction = "deny"
-unused_async = "deny"
-unwrap_used = "deny"
-
-# A subset of pedantic as warn
-cast_lossless = "warn"
-cast_possible_truncation = "warn"
-cast_possible_wrap = "warn"
-cast_precision_loss = "warn"
-cast_ptr_alignment = "warn"
-cast_sign_loss = "warn"
-checked_conversions = "warn"
-if_then_some_else_none = "warn"
-inconsistent_struct_constructor = "allow"
-invalid_upcast_comparisons = "warn"
-large_futures = "warn"
-large_stack_arrays = "warn"
-large_types_passed_by_value = "warn"
+unused_async            = "deny"
+unwrap_used             = "deny"
+uninlined_format_args   = "deny"
+len_without_is_empty    = "deny"
+trivially_copy_pass_by_ref = "allow"
 map_unwrap_or = "allow"
-maybe_infinite_iter = "warn"
-missing_errors_doc = "allow"
-missing_panics_doc = "allow"
-doc_markdown = "allow"
-module_name_repetitions = "allow"
-must_use_candidate = "allow"
-needless_raw_string_hashes = "allow"
-pedantic = { level = "warn", priority = -1 }
-print_stderr = "warn"
-print_stdout = "warn"
-ptr_cast_constness = "warn"
-range_minus_one = "warn"
-range_plus_one = "warn"
-redundant_closure_for_method_calls = "warn"
-return_self_not_must_use = "warn"
-same_functions_in_if_condition = "warn"
+into_iter_on_ref        = "allow"
+inconsistent_struct_constructor = "allow"
 semicolon-if-nothing-returned = "allow"
-similar_names = "warn"
-str_to_string = "warn"
-string_to_string = "warn"
-unicode_not_nfc = "warn"
+missing_errors_doc      = "allow"
+must_use_candidate      = "allow"
+doc_markdown            = "allow"
\ No newline at end of file
diff --git a/clippy.toml b/clippy.toml
index 106a4e09..dde7ef14 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -6,8 +6,6 @@ disallowed-methods = [
   { path = "tokio::time::timeout", reason = "Use pingora_timeout::fast_timeout::fast_timeout instead" },
 ]
 
-# The maximum number of function parameters is 5.
-too-many-arguments-threshold = 5
 
 allow-expect-in-tests = true
 allow-print-in-tests = true
diff --git a/orion-configuration/src/config.rs b/orion-configuration/src/config.rs
index d3cc2c83..efaa15e9 100644
--- a/orion-configuration/src/config.rs
+++ b/orion-configuration/src/config.rs
@@ -122,7 +122,7 @@ mod envoy_conversions {
                 serde_yaml::Deserializer::from_reader(&envoy_file),
                 &mut track,
             ))
-            .with_context(|| format!("failed to deserialize {}", track.path().to_string()))?;
+            .with_context(|| format!("failed to deserialize {}", track.path()))?;
             Bootstrap::try_from(envoy).context("failed to convert into orion bootstrap")
         })()
         .with_context(|| format!("failed to read config from \"{}\"", envoy_path.as_ref().display()))
@@ -137,7 +137,7 @@ mod envoy_conversions {
                     Self { runtime: Runtime::default(), logging: Log::default(), bootstrap }
                 },
                 (Some(config), maybe_override) => {
-                    let ShimConfig { runtime, logging, bootstrap, envoy_bootstrap } = deserialize_yaml(&config)
+                    let ShimConfig { runtime, logging, bootstrap, envoy_bootstrap } = deserialize_yaml(config)
                         .with_context(|| format!("failed to deserialize \"{}\"", config.display()))?;
                     let mut bootstrap = match (bootstrap, envoy_bootstrap) {
                         (None, None) => Bootstrap::default(),
@@ -149,7 +149,7 @@ mod envoy_conversions {
                         },
                     };
                     if let Some(bootstrap_override) = maybe_override {
-                        bootstrap = bootstrap_from_path_to_envoy_bootstrap(&bootstrap_override)?;
+                        bootstrap = bootstrap_from_path_to_envoy_bootstrap(bootstrap_override)?;
                     }
                     Self { runtime, logging, bootstrap }
                 },
@@ -199,10 +199,7 @@ mod envoy_conversions {
                     //     std::fs::write(new_path, serialized.as_bytes())?;
                     // }
                     let deserialized: Config = serde_yaml::from_str(&serialized)?;
-                    if new_conf != deserialized {
-                        tracing::info!("\n{}\n", serde_yaml::to_string(&deserialized)?);
-                        panic!("failed to roundtrip config transcoding")
-                    }
+                    assert_eq!(new_conf, deserialized, "failed to roundtrip config transcoding");
                 } else {
                     tracing::info!("skipping {}", path.display())
                 }
diff --git a/orion-configuration/src/config/cluster.rs b/orion-configuration/src/config/cluster.rs
index 25782566..c850f093 100644
--- a/orion-configuration/src/config/cluster.rs
+++ b/orion-configuration/src/config/cluster.rs
@@ -497,10 +497,9 @@ mod envoy_conversions {
                 Ok(Self { endpoints })
             })();
             if !cluster_name.is_empty() {
-                ret.with_name(cluster_name)
-            } else {
-                ret
+                return ret.with_name(cluster_name);
             }
+            ret
         }
     }
 
diff --git a/orion-configuration/src/config/cluster/health_check.rs b/orion-configuration/src/config/cluster/health_check.rs
index 1ce6ce5d..5e27cd34 100644
--- a/orion-configuration/src/config/cluster/health_check.rs
+++ b/orion-configuration/src/config/cluster/health_check.rs
@@ -197,6 +197,7 @@ pub struct HttpHealthCheck {
     pub path: Option<PathAndQuery>,
 }
 
+#[allow(clippy::single_range_in_vec_init)]
 fn default_expected_statuses() -> Vec<Range<u16>> {
     vec![200..201]
 }
@@ -206,6 +207,7 @@ fn is_default_expected_statuses(value: &Vec<Range<u16>>) -> bool {
 }
 
 impl Default for HttpHealthCheck {
+    #[allow(clippy::single_range_in_vec_init)]
     fn default() -> Self {
         Self {
             http_version: Codec::Http1,
@@ -349,6 +351,7 @@ mod envoy_conversions {
                     .with_node("interval_jitter")
             })?;
             let interval_jitter_percent = {
+                #[allow(clippy::cast_precision_loss)]
                 let as_float = interval_jitter_percent as f32;
                 if !as_float.is_finite() || as_float > 1.0 || as_float.is_sign_negative() {
                     Err(GenericError::from_msg(format!(
@@ -431,6 +434,7 @@ mod envoy_conversions {
                 } else if start < 100 || end >= 600 {
                     Err(GenericError::from_msg("invalid range [{start},{end}). Range has to be within [100,600)."))
                 } else {
+                    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
                     Ok((start as u16)..(end as u16))
                 }
             })
diff --git a/orion-configuration/src/config/cluster/http_protocol_options.rs b/orion-configuration/src/config/cluster/http_protocol_options.rs
index 1942d4cd..d2d21451 100644
--- a/orion-configuration/src/config/cluster/http_protocol_options.rs
+++ b/orion-configuration/src/config/cluster/http_protocol_options.rs
@@ -78,7 +78,7 @@ enum ExplicitProtocolOptions {
 
 impl Default for ExplicitProtocolOptions {
     fn default() -> Self {
-        Self::Http1(Http1ProtocolOptions::default())
+        Self::Http1(Http1ProtocolOptions)
     }
 }
 
@@ -239,10 +239,10 @@ mod envoy_conversions {
             let common = common_http_protocol_options.map(CommonHttpOptions::try_from).transpose()?.unwrap_or_default();
             let (codec, http1_options, http2_options) = match upstream_protocol_options {
                 UpstreamHttpProtocolOptions::Explicit(ExplicitProtocolOptions::Http1(http1)) => {
-                    (Codec::Http1, http1, Default::default())
+                    (Codec::Http1, http1, Http2ProtocolOptions::default())
                 },
                 UpstreamHttpProtocolOptions::Explicit(ExplicitProtocolOptions::Http2(http2)) => {
-                    (Codec::Http2, Default::default(), http2)
+                    (Codec::Http2, Http1ProtocolOptions, http2)
                 },
             };
 
diff --git a/orion-configuration/src/config/core.rs b/orion-configuration/src/config/core.rs
index 72e6db6c..27b17e5d 100644
--- a/orion-configuration/src/config/core.rs
+++ b/orion-configuration/src/config/core.rs
@@ -88,7 +88,7 @@ impl<'a> DataSourceReader<'a> {
     }
 }
 
-impl<'a> Read for DataSourceReader<'a> {
+impl Read for DataSourceReader<'_> {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         match self {
             Self::OwnedBytes { bytes, read } => {
@@ -105,7 +105,7 @@ impl<'a> Read for DataSourceReader<'a> {
     }
 }
 
-impl<'a> BufRead for DataSourceReader<'a> {
+impl BufRead for DataSourceReader<'_> {
     fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
         match self {
             Self::OwnedBytes { bytes, read } => Ok(&bytes[*read..]),
@@ -134,7 +134,7 @@ pub struct StringMatcher {
 }
 
 pub(crate) struct CaseSensitive<'a>(pub bool, pub &'a str);
-impl<'a> CaseSensitive<'a> {
+impl CaseSensitive<'_> {
     #[inline]
     pub fn equals(&self, b: &str) -> bool {
         if self.0 {
diff --git a/orion-configuration/src/config/listener.rs b/orion-configuration/src/config/listener.rs
index b8b9d16e..b10af2c7 100644
--- a/orion-configuration/src/config/listener.rs
+++ b/orion-configuration/src/config/listener.rs
@@ -178,7 +178,7 @@ impl FilterChainMatch {
                     let bits_matched = match ip {
                         IpAddr::V4(_) => 32,
                         IpAddr::V6(_) => 128,
-                    } - (range.prefix_len() as u32);
+                    } - u32::from(range.prefix_len());
                     MatchResult::Matched(bits_matched)
                 } else {
                     MatchResult::FailedMatch
@@ -593,6 +593,7 @@ mod envoy_conversions {
         }
     }
 
+    #[allow(clippy::large_enum_variant)]
     #[derive(Debug, Clone)]
     enum SupportedEnvoyFilter {
         HttpConnectionManager(EnvoyHttpConnectionManager),
diff --git a/orion-configuration/src/config/log.rs b/orion-configuration/src/config/log.rs
index 3ca03f81..5cfa9a43 100644
--- a/orion-configuration/src/config/log.rs
+++ b/orion-configuration/src/config/log.rs
@@ -54,6 +54,7 @@ where
     })
 }
 
+#[allow(clippy::ref_option)]
 fn serialize_log_level<S: Serializer>(
     value: &Option<EnvFilter>,
     serializer: S,
diff --git a/orion-configuration/src/config/network_filters/http_connection_manager.rs b/orion-configuration/src/config/network_filters/http_connection_manager.rs
index 5221c8e8..66d3743d 100644
--- a/orion-configuration/src/config/network_filters/http_connection_manager.rs
+++ b/orion-configuration/src/config/network_filters/http_connection_manager.rs
@@ -777,13 +777,13 @@ mod envoy_conversions {
         }
     }
 
+    // In the original Protobuf specification, this enum is `oneof` rds, route_config or scoped_routes,
+    // this is why the name of the field is manually added in case an error happens.
     impl TryFrom<Option<EnvoyRouteSpecifier>> for RouteSpecifier {
         type Error = GenericError;
         fn try_from(envoy: Option<EnvoyRouteSpecifier>) -> Result<Self, Self::Error> {
             Ok(match envoy {
-                Some(EnvoyRouteSpecifier::Rds(rds)) => {
-                    Self::Rds(RdsSpecifier::try_from(rds).map_err(|e| e.with_node("rds"))?)
-                },
+                Some(EnvoyRouteSpecifier::Rds(rds)) => Self::Rds(RdsSpecifier::try_from(rds).with_node("rds")?),
                 Some(EnvoyRouteSpecifier::RouteConfig(envoy)) => {
                     Self::RouteConfig(envoy.try_into().with_node("route_config")?)
                 },
diff --git a/orion-configuration/src/config/network_filters/http_connection_manager/header_matcher.rs b/orion-configuration/src/config/network_filters/http_connection_manager/header_matcher.rs
index ff554dc5..0fd257b3 100644
--- a/orion-configuration/src/config/network_filters/http_connection_manager/header_matcher.rs
+++ b/orion-configuration/src/config/network_filters/http_connection_manager/header_matcher.rs
@@ -52,7 +52,7 @@ impl<'de> Deserialize<'de> for HeaderNames {
         D: serde::Deserializer<'de>,
     {
         struct StrVisitor;
-        impl<'de> Visitor<'de> for StrVisitor {
+        impl Visitor<'_> for StrVisitor {
             type Value = HeaderNames;
             fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                 formatter.write_str("`str`")
diff --git a/orion-configuration/src/config/network_filters/http_connection_manager/route.rs b/orion-configuration/src/config/network_filters/http_connection_manager/route.rs
index af656487..c56ff027 100644
--- a/orion-configuration/src/config/network_filters/http_connection_manager/route.rs
+++ b/orion-configuration/src/config/network_filters/http_connection_manager/route.rs
@@ -87,7 +87,7 @@ pub enum PathRewriteSpecifier {
 
 impl PathRewriteSpecifier {
     /// will preserve the query part of the input if the replacement does not contain one
-    #[must_use]
+    #[allow(clippy::redundant_else)]
     pub fn apply(
         &self,
         path_and_query: Option<&PathAndQuery>,
@@ -255,6 +255,7 @@ const DEFAULT_TIMEOUT: Duration = Duration::from_secs(15);
 const fn default_timeout_deser() -> Option<Duration> {
     Some(DEFAULT_TIMEOUT)
 }
+#[allow(clippy::ref_option)]
 fn is_default_timeout(timeout: &Option<Duration>) -> bool {
     *timeout == default_timeout_deser()
 }
diff --git a/orion-configuration/src/config/runtime.rs b/orion-configuration/src/config/runtime.rs
index a38233ea..7f280dbc 100644
--- a/orion-configuration/src/config/runtime.rs
+++ b/orion-configuration/src/config/runtime.rs
@@ -96,6 +96,7 @@ impl Runtime {
     }
 }
 
+#[allow(clippy::expect_used)]
 pub(crate) fn non_zero_num_cpus() -> NonZeroUsize {
     NonZeroUsize::try_from(num_cpus::get()).expect("found zero cpus")
 }
diff --git a/orion-configuration/src/config/transport.rs b/orion-configuration/src/config/transport.rs
index 06e5ccc4..f4e39f35 100644
--- a/orion-configuration/src/config/transport.rs
+++ b/orion-configuration/src/config/transport.rs
@@ -447,6 +447,7 @@ mod envoy_conversions {
         }
     }
 
+    #[allow(clippy::large_enum_variant)]
     pub(crate) enum SupportedEnvoyTransportSocket {
         DownstreamTlsContext(EnvoyDownstreamTlsContext),
         UpstreamTlsContext(EnvoyUpstreamTlsContext),
diff --git a/orion-configuration/src/lib.rs b/orion-configuration/src/lib.rs
index 3182a3a4..e6dfc34c 100644
--- a/orion-configuration/src/lib.rs
+++ b/orion-configuration/src/lib.rs
@@ -22,6 +22,7 @@
 use orion_error::Error;
 pub(crate) type BoxedError = Box<dyn std::error::Error + Send + Sync>;
 
+#[allow(clippy::wildcard_imports, clippy::too_many_lines)]
 pub mod config;
 pub mod options;
 
@@ -74,7 +75,7 @@ mod tests {
                 name: "http-router".to_owned(),
                 config_type: Some(ConfigType::TypedConfig(Any {
                     type_url: "type.googleapis.com/envoy.extensions.filters.http.router.v3.Router".to_owned(),
-                    value: vec![].into(),
+                    value: vec![],
                 })),
                 ..Default::default()
             }],
diff --git a/orion-lib/src/body/timeout_body.rs b/orion-lib/src/body/timeout_body.rs
index 7b601233..0bb1e4c3 100644
--- a/orion-lib/src/body/timeout_body.rs
+++ b/orion-lib/src/body/timeout_body.rs
@@ -32,7 +32,7 @@
 use http_body::Body;
 use pin_project::pin_project;
 use pingora_timeout::fast_timeout::{fast_timeout, FastTimeout};
-use pingora_timeout::Timeout;
+use pingora_timeout::Timeout as PingoraTimeout;
 use std::{
     future::{pending, Future, Pending},
     pin::Pin,
@@ -40,11 +40,13 @@ use std::{
     time::Duration,
 };
 
+pub type Timeout = PingoraTimeout<Pending<()>, FastTimeout>;
+
 #[pin_project]
 pub struct TimeoutBody<B> {
     timeout: Option<Duration>,
     #[pin]
-    sleep: Option<Pin<Box<Timeout<Pending<()>, FastTimeout>>>>,
+    sleep: Option<Pin<Box<Timeout>>>,
     #[pin]
     body: B,
 }
@@ -78,7 +80,7 @@ where
             };
 
             // Error if the timeout has expired.
-            if let Poll::Ready(_) = sleep_pinned.poll(cx) {
+            if sleep_pinned.poll(cx).is_ready() {
                 return Poll::Ready(Some(Err(TimeoutBodyError::TimedOut)));
             }
 
diff --git a/orion-lib/src/clusters/balancers/least.rs b/orion-lib/src/clusters/balancers/least.rs
index 04fc2dc4..3c96e8f3 100644
--- a/orion-lib/src/clusters/balancers/least.rs
+++ b/orion-lib/src/clusters/balancers/least.rs
@@ -69,6 +69,7 @@ impl<E: EndpointWithLoad> WeightedLeastRequestBalancer<E> {
         Self::new_with_settings(items, DEFAULT_ACTIVE_REQUEST_BIAS, u32::from(DEFAULT_P2C_CHOICE_COUNT))
     }
 
+    #[allow(clippy::expect_used)]
     fn new_with_settings(
         items: impl IntoIterator<Item = LbItem<E>>,
         active_request_bias: f32,
diff --git a/orion-lib/src/clusters/balancers/random.rs b/orion-lib/src/clusters/balancers/random.rs
index 2e51ab58..ad902527 100644
--- a/orion-lib/src/clusters/balancers/random.rs
+++ b/orion-lib/src/clusters/balancers/random.rs
@@ -36,6 +36,7 @@ pub struct RandomBalancer<E> {
 }
 
 impl<E> RandomBalancer<E> {
+    #[allow(clippy::expect_used)]
     pub fn new(items: impl IntoIterator<Item = LbItem<E>>) -> Self {
         let rng = SmallRng::from_rng(rand::thread_rng()).expect("RNG must be valid");
         RandomBalancer::new_with_rng(items, rng)
diff --git a/orion-lib/src/clusters/cached_watch.rs b/orion-lib/src/clusters/cached_watch.rs
index 0b1a80f7..ba1fb82b 100644
--- a/orion-lib/src/clusters/cached_watch.rs
+++ b/orion-lib/src/clusters/cached_watch.rs
@@ -66,7 +66,7 @@ pub struct CachedWatcher<'a, T: Clone> {
     local: T,
 }
 
-impl<'a, T: Clone> CachedWatcher<'a, T> {
+impl<T: Clone> CachedWatcher<'_, T> {
     pub fn cached_or_latest(&mut self) -> &mut T {
         let parent_version = self.parent.version();
         if parent_version != self.version {
diff --git a/orion-lib/src/clusters/health/checkers/grpc/mod.rs b/orion-lib/src/clusters/health/checkers/grpc/mod.rs
index 42833e96..4213a72b 100644
--- a/orion-lib/src/clusters/health/checkers/grpc/mod.rs
+++ b/orion-lib/src/clusters/health/checkers/grpc/mod.rs
@@ -31,6 +31,7 @@ use orion_xds::grpc_deps::tonic_health::pb::{
     health_check_response::ServingStatus, HealthCheckRequest, HealthCheckResponse,
 };
 use orion_xds::grpc_deps::{Response as TonicResponse, Status as TonicStatus};
+use std::future::Future;
 use tokio::sync::{mpsc, Notify};
 use tokio::task::JoinHandle;
 
@@ -118,10 +119,7 @@ where
 {
     type Response = HealthCheckResponse;
 
-    fn check(
-        &mut self,
-    ) -> impl futures::Future<Output = std::result::Result<<Self as ProtocolChecker>::Response, orion_error::Error>>
-           + std::marker::Send {
+    fn check(&mut self) -> impl Future<Output = Result<Self::Response, Error>> + Send {
         async move {
             let request = HealthCheckRequest { service: self.config.service_name.clone().into() };
             Ok(self.channel.check(request).await.map(TonicResponse::into_inner)?)
diff --git a/orion-lib/src/clusters/load_assignment.rs b/orion-lib/src/clusters/load_assignment.rs
index 7f1ca20d..1029b3e8 100644
--- a/orion-lib/src/clusters/load_assignment.rs
+++ b/orion-lib/src/clusters/load_assignment.rs
@@ -266,12 +266,20 @@ impl LocalityLbEndpointsBuilder {
                     .build()
             })
             .collect::<Result<_>>()?;
+
+        let total_endpoints_usize = endpoints.len();
+        let healthy_endpoints_usize = endpoints.iter().filter(|e| e.health_status.is_healthy()).count();
+
+        let (Ok(total_endpoints), Ok(healthy_endpoints)) =
+            (u32::try_from(total_endpoints_usize), u32::try_from(healthy_endpoints_usize))
+        else {
+            return Err("Too many endpoints".into());
+        };
+
         // we divide by 100 because we multiply by 100 later to calculate a percentage
-        if endpoints.len() > (u32::MAX / 100) as usize {
+        if healthy_endpoints > u32::MAX / 100 {
             return Err("Too many endpoints".into());
         }
-        let healthy_endpoints = endpoints.iter().filter(|e| e.health_status.is_healthy()).count() as u32;
-        let total_endpoints = endpoints.len() as u32;
 
         Ok(LocalityLbEndpoints {
             name: cluster_name,
diff --git a/orion-lib/src/clusters/retry_policy.rs b/orion-lib/src/clusters/retry_policy.rs
index ab1c7801..63b3f976 100644
--- a/orion-lib/src/clusters/retry_policy.rs
+++ b/orion-lib/src/clusters/retry_policy.rs
@@ -72,7 +72,7 @@ impl<'a, B: Body> FailureKind<'a, B> {
                 if resp.status().is_informational() || resp.status().is_success() {
                     return None;
                 }
-                return Some(FailureKind::EligibleForRetry(resp));
+                Some(FailureKind::EligibleForRetry(resp))
             },
             Err(err) => Self::try_infer_from_error(err.as_ref()),
         }
diff --git a/orion-lib/src/configuration/mod.rs b/orion-lib/src/configuration/mod.rs
index f8ad3926..05a5d6a0 100644
--- a/orion-lib/src/configuration/mod.rs
+++ b/orion-lib/src/configuration/mod.rs
@@ -31,7 +31,7 @@ pub fn get_listeners_and_clusters(
     let static_resources = bootstrap.static_resources;
     let secrets = static_resources.secrets;
     let mut secret_manager = SecretManager::new();
-    secrets.into_iter().try_for_each(|secret| secret_manager.add(secret).map(|_| ()))?;
+    secrets.into_iter().try_for_each(|secret| secret_manager.add(&secret).map(|_| ()))?;
 
     let listeners = static_resources
         .listeners
diff --git a/orion-lib/src/lib.rs b/orion-lib/src/lib.rs
index 5897bd76..9f4563d9 100644
--- a/orion-lib/src/lib.rs
+++ b/orion-lib/src/lib.rs
@@ -56,6 +56,7 @@ pub type HttpBody = PolyBody;
 
 pub static RUNTIME_CONFIG: OnceLock<Runtime> = OnceLock::new();
 
+#[allow(clippy::expect_used, clippy::missing_panics_doc)]
 pub fn runtime_config() -> &'static Runtime {
     RUNTIME_CONFIG.get().expect("Called runtime_config without setting RUNTIME_CONFIG first")
 }
diff --git a/orion-lib/src/listeners/filterchain.rs b/orion-lib/src/listeners/filterchain.rs
index 3b1bb1c0..d9d67bf4 100644
--- a/orion-lib/src/listeners/filterchain.rs
+++ b/orion-lib/src/listeners/filterchain.rs
@@ -213,7 +213,7 @@ impl FilterchainType {
                         stream,
                         hyper::service::service_fn(|req: Request<hyper::body::Incoming>| {
                             let handler_req = HttpHandlerRequest { request: req, source_addr: peer_addr };
-                            req_handler.call(handler_req).map_err(|e| e.inner())
+                            req_handler.call(handler_req).map_err(orion_error::Error::inner)
                         }),
                     )
                     .await
diff --git a/orion-lib/src/listeners/http_connection_manager.rs b/orion-lib/src/listeners/http_connection_manager.rs
index d1c788a6..2b99fe80 100644
--- a/orion-lib/src/listeners/http_connection_manager.rs
+++ b/orion-lib/src/listeners/http_connection_manager.rs
@@ -201,8 +201,8 @@ impl fmt::Display for HttpConnectionManager {
 }
 
 impl HttpConnectionManager {
-    pub fn get_route_id(&self) -> &Option<CompactString> {
-        &self.dynamic_route_name
+    pub fn get_route_id(&self) -> Option<&CompactString> {
+        self.dynamic_route_name.as_ref()
     }
 
     pub fn update_route(&self, route: Arc<RouteConfiguration>) {
@@ -323,9 +323,6 @@ impl Service<HttpHandlerRequest> for HttpRequestHandler {
 // This function should check permissions and return forbidden response if access is denied
 fn apply_authorization_rules<B>(rbac: &HttpRbac, req: &Request<B>) -> Option<Response<HttpBody>> {
     debug!("Applying authorization rules {rbac:?} {:?}", &req.headers());
-    if !rbac.is_permitted(req) {
-        Some(SyntheticHttpResponse::forbidden("RBAC: access denied").into_response(req.version()))
-    } else {
-        None
-    }
+    (!rbac.is_permitted(req))
+        .then(|| SyntheticHttpResponse::forbidden("RBAC: access denied").into_response(req.version()))
 }
diff --git a/orion-lib/src/listeners/http_connection_manager/redirect.rs b/orion-lib/src/listeners/http_connection_manager/redirect.rs
index 4cd8b7ae..a9e86069 100644
--- a/orion-lib/src/listeners/http_connection_manager/redirect.rs
+++ b/orion-lib/src/listeners/http_connection_manager/redirect.rs
@@ -43,7 +43,7 @@ impl RequestHandler<(Request<TimeoutBody<Incoming>>, RouteMatchResult)> for &Red
         let UriParts { scheme: orig_scheme, authority: orig_authority, path_and_query: orig_path_and_query, .. } =
             parts.uri.into_parts();
         let orig_host = orig_authority.as_ref().map(Authority::host);
-        let orig_port = orig_authority.as_ref().map(Authority::port_u16).flatten();
+        let orig_port = orig_authority.as_ref().and_then(Authority::port_u16);
         let authority = match (self.authority_redirect.as_ref(), (orig_host, orig_port)) {
             //no redirect
             (None, _) => orig_authority,
diff --git a/orion-lib/src/listeners/listener.rs b/orion-lib/src/listeners/listener.rs
index 782bf86f..25e4406c 100644
--- a/orion-lib/src/listeners/listener.rs
+++ b/orion-lib/src/listeners/listener.rs
@@ -213,10 +213,6 @@ impl Listener {
         destination_addr: SocketAddr,
         server_name: Option<&str>,
     ) -> Result<Option<&'a T>> {
-        //todo: smallvec? other optimization?
-        let mut possible_filters = vec![true; filter_chains.len()];
-        let mut scratchpad = vec![MatchResult::NoRule; filter_chains.len()];
-
         fn match_subitem<'a, F: Fn(&FilterChainMatch, T) -> MatchResult, T: Copy>(
             function: F,
             comparand: T,
@@ -242,6 +238,10 @@ impl Listener {
             }
         }
 
+        //todo: smallvec? other optimization?
+        let mut possible_filters = vec![true; filter_chains.len()];
+        let mut scratchpad = vec![MatchResult::NoRule; filter_chains.len()];
+
         match_subitem(
             FilterChainMatch::matches_destination_port,
             destination_addr.port(),
@@ -324,9 +324,8 @@ impl Listener {
             );
             if let Some(stream) = filterchain.apply_rbac(stream, local_address, peer_addr, server_name.as_deref()) {
                 return filterchain.start_filterchain(stream).await;
-            } else {
-                debug!("{listener_name} : dropped connection from {peer_addr} due to rbac");
             }
+            debug!("{listener_name} : dropped connection from {peer_addr} due to rbac");
         } else {
             warn!("{listener_name} : No match for {peer_addr} {local_address}");
         }
@@ -553,14 +552,14 @@ filter_chains:
         ",
         )
         .unwrap();
-        let m: HashMap<FilterChainMatch, _> = std::iter::once((m.try_into().unwrap(), ())).collect();
+        let m = std::iter::once((m.try_into().unwrap(), ())).collect();
         let good_source = (Ipv4Addr::LOCALHOST, 3300).into();
         let good_destination = (Ipv4Addr::LOCALHOST, 443).into();
         let good_host = Some("host.test");
-        assert!(matches!(Listener::select_filterchain(&m, good_source, good_destination, good_host), Ok(Some(_))));
+        assert!(matches!(Listener::select_filterchain(&m, good_source, good_destination, good_host), Ok(Some(()))));
         assert!(matches!(
             Listener::select_filterchain(&m, good_source, good_destination, Some("a.wildcard")),
-            Ok(Some(_))
+            Ok(Some(()))
         ));
         assert!(matches!(Listener::select_filterchain(&m, good_source, good_destination, None), Ok(None)));
         assert!(matches!(
diff --git a/orion-lib/src/listeners/rate_limiter/mod.rs b/orion-lib/src/listeners/rate_limiter/mod.rs
index e53639e8..68fd1cb4 100644
--- a/orion-lib/src/listeners/rate_limiter/mod.rs
+++ b/orion-lib/src/listeners/rate_limiter/mod.rs
@@ -25,6 +25,7 @@ use std::sync::Arc;
 use http::status::StatusCode;
 use http::Request;
 use hyper::Response;
+use tracing::warn;
 
 use token_bucket::TokenBucket;
 
@@ -33,6 +34,7 @@ use orion_configuration::config::network_filters::http_connection_manager::http_
 use crate::listeners::synthetic_http_response::SyntheticHttpResponse;
 use crate::{runtime_config, HttpBody};
 
+#[allow(dead_code)]
 #[derive(Debug, Clone)]
 // TODO: Implement rate limiting functionality - this struct defines the interface for local rate limits
 pub struct LocalRateLimit {
@@ -40,6 +42,7 @@ pub struct LocalRateLimit {
     pub token_bucket: Arc<TokenBucket>,
 }
 
+#[allow(dead_code)]
 impl LocalRateLimit {
     // TODO: Implement rate limit enforcement - used to check and consume tokens for incoming requests
     pub fn run<B>(&self, req: &Request<B>) -> Option<Response<HttpBody>> {
@@ -57,11 +60,14 @@ impl From<LocalRateLimitConfig> for LocalRateLimit {
         let max_tokens = rate_limit.max_tokens;
         let tokens_per_fill = rate_limit.tokens_per_fill;
         let fill_interval = rate_limit.fill_interval;
-        let token_bucket = Arc::new(TokenBucket::new(
-            max_tokens,
-            tokens_per_fill,
-            fill_interval.checked_mul(runtime_config().num_runtimes.into()).expect("too many runtimes (overflow)"),
-        ));
+        let adjusted_fill_interval = fill_interval.checked_mul(runtime_config().num_runtimes.into());
+        let fill_interval = if let Some(value) = adjusted_fill_interval {
+            value
+        } else {
+            warn!("failed to adjust fill interval to number of configured runtimes (overflow)");
+            fill_interval
+        };
+        let token_bucket = Arc::new(TokenBucket::new(max_tokens, tokens_per_fill, fill_interval));
 
         Self { status, token_bucket }
     }
diff --git a/orion-lib/src/listeners/synthetic_http_response.rs b/orion-lib/src/listeners/synthetic_http_response.rs
index 80d2ad89..872bafc7 100644
--- a/orion-lib/src/listeners/synthetic_http_response.rs
+++ b/orion-lib/src/listeners/synthetic_http_response.rs
@@ -29,7 +29,7 @@ use http_body_util::Full;
 // TODO: Error type for synthetic response validation - implement validation logic or remove if unused
 pub enum InvalidSyntheticResponse {
     #[error(transparent)]
-    InvalidHttpResponse(#[from] http::Error),
+    BadHttpResponse(#[from] http::Error),
     #[error(transparent)]
     InvalidHeaderValue(#[from] http::header::InvalidHeaderValue),
     #[error(transparent)]
@@ -56,7 +56,7 @@ impl SyntheticHttpResponse {
         Self { http_status: StatusCode::BAD_GATEWAY, body: Bytes::default(), close_connection: true }
     }
 
-    // TODO: Implement forbidden response functionality - used for access control features
+    #[allow(dead_code)]
     pub fn forbidden(msg: &str) -> Self {
         Self {
             http_status: StatusCode::FORBIDDEN,
diff --git a/orion-lib/src/secrets/secrets_manager.rs b/orion-lib/src/secrets/secrets_manager.rs
index 6d7e8d99..4cee6449 100644
--- a/orion-lib/src/secrets/secrets_manager.rs
+++ b/orion-lib/src/secrets/secrets_manager.rs
@@ -138,7 +138,7 @@ impl SecretManager {
         Self { certificate_secrets: HashMap::default(), validation_contexts: HashMap::default() }
     }
 
-    pub fn add(&mut self, secret: Secret) -> Result<TransportSecret> {
+    pub fn add(&mut self, secret: &Secret) -> Result<TransportSecret> {
         let secret_id = secret.name();
         let secret = match secret.kind() {
             Type::TlsCertificate(certificate) => {
diff --git a/orion-lib/src/transport/bind_device.rs b/orion-lib/src/transport/bind_device.rs
index 1f8412d7..7ccffb03 100644
--- a/orion-lib/src/transport/bind_device.rs
+++ b/orion-lib/src/transport/bind_device.rs
@@ -34,6 +34,7 @@ pub(crate) fn bind_device(_: &tokio::net::TcpSocket, _: &BindDevice) -> std::io:
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::manual_c_str_literals)]
     use std::ffi::CStr;
 
     use super::*;
@@ -160,7 +161,7 @@ mod tests {
     fn direct_decode_bytes() {
         let yaml = "interface_bytes: YRs=";
         let iface = CStr::from_bytes_with_nul(b"a\x1b\0").unwrap();
-        let bd: BindDevice = serde_yaml::from_str(&yaml).unwrap();
+        let bd: BindDevice = serde_yaml::from_str(yaml).unwrap();
         assert_eq!(iface, bd.interface())
     }
 
@@ -168,7 +169,7 @@ mod tests {
     fn direct_decode_iface() {
         let yaml = "interface: eth0";
         let iface = CStr::from_bytes_with_nul(b"eth0\0").unwrap();
-        let bd: BindDevice = serde_yaml::from_str(&yaml).unwrap();
+        let bd: BindDevice = serde_yaml::from_str(yaml).unwrap();
         assert_eq!(iface, bd.interface())
     }
 }
diff --git a/orion-lib/src/transport/http_channel.rs b/orion-lib/src/transport/http_channel.rs
index 0b011eb3..53a0506a 100644
--- a/orion-lib/src/transport/http_channel.rs
+++ b/orion-lib/src/transport/http_channel.rs
@@ -122,7 +122,7 @@ impl HttpChannelBuilder {
             tls: None,
             authority: None,
             bind_device,
-            http_protocol_options: Default::default(),
+            http_protocol_options: HttpProtocolOptions::default(),
             server_name: None,
             connection_timeout: None,
         }
@@ -241,12 +241,12 @@ impl<'a> RequestHandler<RequestWithContext<'a, HttpBody>> for &HttpChannel {
                 let req = maybe_normalize_uri(request.req, false)?;
 
                 let result = if let Some(t) = route_timeout {
-                    match fast_timeout(t, HttpChannel::send_request(retry_policy.as_deref(), sender, req)).await {
+                    match fast_timeout(t, HttpChannel::send_request(retry_policy, sender, req)).await {
                         Ok(result) => result,
                         Err(_) => (Err(EventError::RouteTimeout.into()), t),
                     }
                 } else {
-                    HttpChannel::send_request(retry_policy.as_deref(), sender, req).await
+                    HttpChannel::send_request(retry_policy, sender, req).await
                 };
                 HttpChannel::handle_response(result, route_timeout, version)
             },
@@ -261,12 +261,12 @@ impl<'a> RequestHandler<RequestWithContext<'a, HttpBody>> for &HttpChannel {
                 let req = maybe_normalize_uri(request.req, true)?;
                 let req = maybe_change_http_protocol_version(req, configured_version)?;
                 let result = if let Some(t) = route_timeout {
-                    match fast_timeout(t, HttpChannel::send_request(retry_policy.as_deref(), sender, req)).await {
+                    match fast_timeout(t, HttpChannel::send_request(retry_policy, sender, req)).await {
                         Ok(result) => result,
                         Err(_) => (Err(EventError::RouteTimeout.into()), t),
                     }
                 } else {
-                    HttpChannel::send_request(retry_policy.as_deref(), sender, req).await
+                    HttpChannel::send_request(retry_policy, sender, req).await
                 };
 
                 HttpChannel::handle_response(result, route_timeout, version)
@@ -287,7 +287,7 @@ impl HttpChannel {
     where
         C: Connect + Clone + Send + Sync + 'static,
     {
-        if let Some(ref policy) = retry_policy {
+        if let Some(policy) = retry_policy {
             if policy.is_retriable(&req) {
                 Self::send_with_retry(policy, sender, req).await
             } else {
diff --git a/orion-lib/src/transport/tls_inspector.rs b/orion-lib/src/transport/tls_inspector.rs
index d3f3a5a4..57679feb 100644
--- a/orion-lib/src/transport/tls_inspector.rs
+++ b/orion-lib/src/transport/tls_inspector.rs
@@ -44,7 +44,7 @@ impl<'a> TlsInspector<'a> {
     }
 }
 
-impl<'a> AsyncRead for TlsInspector<'a> {
+impl AsyncRead for TlsInspector<'_> {
     fn poll_read(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
@@ -92,7 +92,7 @@ impl<'a> AsyncRead for TlsInspector<'a> {
 //
 // for now, we simply error out on any writes. The TLS protocol should not require that we write anything before receiving the initial handshake
 // see https://tls13.xargs.org/
-impl<'a> AsyncWrite for TlsInspector<'a> {
+impl AsyncWrite for TlsInspector<'_> {
     fn poll_flush(
         self: Pin<&mut Self>,
         _: &mut std::task::Context<'_>,
diff --git a/orion-proxy/src/core_affinity.rs b/orion-proxy/src/core_affinity.rs
index 79e012f5..b09a4039 100644
--- a/orion-proxy/src/core_affinity.rs
+++ b/orion-proxy/src/core_affinity.rs
@@ -193,6 +193,7 @@ fn run_strategy(
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::too_many_lines)]
     use super::*;
 
     #[test]
diff --git a/orion-proxy/src/lib.rs b/orion-proxy/src/lib.rs
index f9051244..e048ed3e 100644
--- a/orion-proxy/src/lib.rs
+++ b/orion-proxy/src/lib.rs
@@ -91,7 +91,7 @@ mod proxy_tracing {
             // Update tracing layer if necessary (stdout -> file)
             if let Some(log_file) = log_conf.log_file {
                 self.layer_reload_handle.modify(|layer| {
-                    let (new_guard, new_layer) = Self::file_layer(&log_file, log_conf.log_directory);
+                    let (new_guard, new_layer) = Self::file_layer(&log_file, log_conf.log_directory.as_ref());
                     *layer = new_layer;
                     self.guard = new_guard;
                 })?;
@@ -139,9 +139,8 @@ mod proxy_tracing {
         }
 
         #[cfg(not(feature = "console"))]
-        fn file_layer(filename: &str, log_directory: Option<String>) -> (WorkerGuard, RegistryLayer) {
-            let file_appender =
-                tracing_appender::rolling::hourly(log_directory.as_ref().unwrap_or(&".".into()), filename);
+        fn file_layer(filename: &str, log_directory: Option<&String>) -> (WorkerGuard, RegistryLayer) {
+            let file_appender = tracing_appender::rolling::hourly(log_directory.unwrap_or(&".".into()), filename);
             let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
             let file_layer = fmt::layer().with_ansi(false).with_writer(non_blocking).with_thread_names(true);
 
diff --git a/orion-proxy/src/proxy.rs b/orion-proxy/src/proxy.rs
index 460379d6..28be9476 100644
--- a/orion-proxy/src/proxy.rs
+++ b/orion-proxy/src/proxy.rs
@@ -148,7 +148,7 @@ fn spawn_runtime_from_thread(num_threads: usize, runtime_id: RuntimeId) -> Resul
     Ok((handle, configuration_senders))
 }
 
-//TODO: this is crap
+#[allow(clippy::too_many_arguments)]
 fn xds_loop(
     node: Node,
     configuration_senders: Vec<ConfigurationSenders>,
@@ -168,7 +168,7 @@ fn xds_loop(
             format!("xdstask_{id}")
         })
         .build()
-        .expect("failed to build basic runtime");
+        .with_context(|| "failed to build basic runtime")?;
     runtime.block_on(async move {
         let secret_manager =
             configure_initial_resources(secret_manager, listeners, configuration_senders.clone()).await?;
diff --git a/orion-proxy/src/xds_configurator.rs b/orion-proxy/src/xds_configurator.rs
index 1b639197..6f0c0750 100644
--- a/orion-proxy/src/xds_configurator.rs
+++ b/orion-proxy/src/xds_configurator.rs
@@ -260,7 +260,7 @@ impl XdsConfigurationHandler {
             },
             XdsResourcePayload::Secret(id, secret) => {
                 debug!("Got update for secret {id}: {:#?}", secret);
-                let res = self.secret_manager.add(secret);
+                let res = self.secret_manager.add(&secret);
 
                 match res {
                     Ok(secret) => {
diff --git a/orion-proxy/tests/configs.rs b/orion-proxy/tests/configs.rs
index 49869309..28c6460e 100644
--- a/orion-proxy/tests/configs.rs
+++ b/orion-proxy/tests/configs.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::expect_used)]
 use orion_configuration::config::{Config, Runtime};
 use orion_configuration::options::Options;
 use orion_lib::configuration::get_listeners_and_clusters;
diff --git a/orion-xds/Cargo.toml b/orion-xds/Cargo.toml
index 4ba3454a..6c376f54 100644
--- a/orion-xds/Cargo.toml
+++ b/orion-xds/Cargo.toml
@@ -25,23 +25,6 @@ uuid                   = { version = "1.7.0", features = ["v4"] }
 
 [dev-dependencies]
 serde_yaml.workspace = true
-tokio.workspace      = true
-tracing-subscriber   = { version = "0.3", features = ["env-filter"] }
 
-[lints.clippy]
-clone_on_ref_ptr = "warn"
-doc_markdown = "allow"
-get_unwrap = "allow"
-if_then_some_else_none = "warn"
-missing_docs_in_private_items = "allow"
-missing_errors_doc = "allow"
-missing_panics_doc = "allow"
-module_name_repetitions = "allow"
-must_use_candidate = "allow"
-pedantic = "warn"
-print_stderr = "warn"
-print_stdout = "warn"
-str_to_string = "warn"
-string_to_string = "warn"
-todo = "deny"
-unwrap_used = "deny"
+[lints]
+workspace = true
diff --git a/orion-xds/examples/server_routes_and_loads.rs b/orion-xds/examples/server_routes_and_loads.rs
index 2e326553..8497351f 100644
--- a/orion-xds/examples/server_routes_and_loads.rs
+++ b/orion-xds/examples/server_routes_and_loads.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::expect_used)]
 use std::{future::IntoFuture, time::Duration};
 
 use orion_xds::xds::{
diff --git a/orion-xds/src/xds/bindings.rs b/orion-xds/src/xds/bindings.rs
index 22f502ee..da6ead3e 100644
--- a/orion-xds/src/xds/bindings.rs
+++ b/orion-xds/src/xds/bindings.rs
@@ -18,6 +18,7 @@
 //
 //
 
+#![allow(dead_code)]
 use std::{future::Future, pin::Pin};
 
 use model::TypeUrl;
diff --git a/orion-xds/src/xds/resources/mod.rs b/orion-xds/src/xds/resources/mod.rs
index 7bac2a09..1318b314 100644
--- a/orion-xds/src/xds/resources/mod.rs
+++ b/orion-xds/src/xds/resources/mod.rs
@@ -347,7 +347,7 @@ pub fn create_listener(
         type_url:
             "type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager"
                 .to_owned(),
-        value: http_connection_manager.encode_to_vec().into(),
+        value: http_connection_manager.encode_to_vec(),
     };
 
     let http_connection_manager_filter = Filter {

From 814a88d3849db4db16d4485c31294bad8f5a0455 Mon Sep 17 00:00:00 2001
From: Alan Keane <alan.keane1@huawei.com>
Date: Fri, 28 Feb 2025 12:30:00 +0000
Subject: [PATCH 03/64] Fix logical errors for slow arriving ClientHello

- fix broken comparison where n_bytes >= *bytes_read would error on new data
- fix incorrect read buffer alignment for init and outbound copy
- change read buffer size to be adaptive

Signed-off-by: Alan Keane <alan.keane1@huawei.com>
---
 orion-lib/src/transport/tls_inspector.rs | 33 ++++++++++++++----------
 1 file changed, 19 insertions(+), 14 deletions(-)

diff --git a/orion-lib/src/transport/tls_inspector.rs b/orion-lib/src/transport/tls_inspector.rs
index 57679feb..0300e045 100644
--- a/orion-lib/src/transport/tls_inspector.rs
+++ b/orion-lib/src/transport/tls_inspector.rs
@@ -19,7 +19,7 @@
 //
 
 use rustls::server::Acceptor;
-use std::{pin::Pin, task::Poll};
+use std::{cmp::Ordering, pin::Pin, task::Poll};
 use tokio::{
     io::{AsyncRead, AsyncWrite},
     net::TcpStream,
@@ -61,24 +61,29 @@ impl AsyncRead for TlsInspector<'_> {
                 poll.map(|p| p.map(|_| ()))
             }
         } else {
-            //if we have little space left in the buffer, grow it.
-            // maximum size should be capped by rustls failing the handshake.
-            if buffer.len().checked_sub(*bytes_read).unwrap_or_default() <= 512 {
-                buffer.resize(buffer.len() + 4 * (1 << 10), 0);
+            let write_capacity = buf.remaining();
+            let internal_buffer_bound = *bytes_read + write_capacity;
+            if buffer.len() < internal_buffer_bound {
+                buffer.resize(internal_buffer_bound, 0);
             }
-            let mut peek_read_buf = tokio::io::ReadBuf::new(&mut buffer[..buf.remaining()]);
+            let mut peek_read_buf = tokio::io::ReadBuf::new(buffer);
             let poll = Pin::new(stream).poll_peek(cx, &mut peek_read_buf);
             if let Poll::Ready(Ok(n_bytes)) = poll {
-                //this should never fail, as that would imply we peeked less bytes than we did previously
-                if n_bytes >= *bytes_read {
-                    return Poll::Ready(Err(std::io::Error::other(
+                match n_bytes.cmp(bytes_read) {
+                    Ordering::Greater => {
+                        let newly_read = &peek_read_buf.filled()[*bytes_read..n_bytes];
+                        buf.put_slice(newly_read);
+                        *bytes_read = n_bytes;
+                        Poll::Ready(Ok(()))
+                    },
+                    Ordering::Equal => {
+                        // TODO this case potentially problematic
+                        Poll::Ready(Ok(()))
+                    },
+                    Ordering::Less => Poll::Ready(Err(std::io::Error::other(
                         "TLS inspector peeked less bytes than it did in a previous iteration",
-                    )));
+                    ))),
                 }
-                let newly_read = &peek_read_buf.filled()[*bytes_read..];
-                buf.put_slice(newly_read);
-                *bytes_read = n_bytes;
-                Poll::Ready(Ok(()))
             } else {
                 poll.map(|p| p.map(|_| ()))
             }

From 7f6b556e3e86e9461f6f7378240dc1a7c1fc41e7 Mon Sep 17 00:00:00 2001
From: Alan Keane <alan.keane1@huawei.com>
Date: Wed, 5 Mar 2025 10:06:35 +0000
Subject: [PATCH 04/64] Keep task alive when no data available

Signed-off-by: Alan Keane <alan.keane1@huawei.com>
---
 orion-lib/src/transport/tls_inspector.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/orion-lib/src/transport/tls_inspector.rs b/orion-lib/src/transport/tls_inspector.rs
index 0300e045..07c25a16 100644
--- a/orion-lib/src/transport/tls_inspector.rs
+++ b/orion-lib/src/transport/tls_inspector.rs
@@ -77,8 +77,8 @@ impl AsyncRead for TlsInspector<'_> {
                         Poll::Ready(Ok(()))
                     },
                     Ordering::Equal => {
-                        // TODO this case potentially problematic
-                        Poll::Ready(Ok(()))
+                        cx.waker().wake_by_ref();
+                        Poll::Pending
                     },
                     Ordering::Less => Poll::Ready(Err(std::io::Error::other(
                         "TLS inspector peeked less bytes than it did in a previous iteration",

From f644cd0a3fe3b85055a1361373e7a50a613edf38 Mon Sep 17 00:00:00 2001
From: Hayley Deckers <hayley.deckers@huawei-partners.com>
Date: Tue, 12 Nov 2024 14:44:27 +0000
Subject: [PATCH 05/64] rename traits, allow for context on options

Signed-off-by: Hayley Deckers <hayley.deckers@huawei-partners.com>
---
 orion-configuration/examples/convert.rs       |  2 +-
 orion-configuration/src/config.rs             |  2 +-
 orion-configuration/src/config/log.rs         |  3 +-
 orion-configuration/src/main.rs               |  2 +-
 orion-error/src/lib.rs                        | 46 +++++++++++--------
 .../http_connection_manager/redirect.rs       |  2 +-
 .../http_connection_manager/route.rs          |  2 +-
 orion-proxy/src/proxy.rs                      |  2 +-
 8 files changed, 35 insertions(+), 26 deletions(-)

diff --git a/orion-configuration/examples/convert.rs b/orion-configuration/examples/convert.rs
index 6dbad453..9c819061 100644
--- a/orion-configuration/examples/convert.rs
+++ b/orion-configuration/examples/convert.rs
@@ -1,6 +1,6 @@
 #![allow(clippy::print_stdout)]
 use orion_configuration::config::Bootstrap;
-use orion_error::{Result, ResultExtension};
+use orion_error::{Context, Result};
 use std::fs::File;
 
 fn main() -> Result<()> {
diff --git a/orion-configuration/src/config.rs b/orion-configuration/src/config.rs
index efaa15e9..582b9395 100644
--- a/orion-configuration/src/config.rs
+++ b/orion-configuration/src/config.rs
@@ -96,7 +96,7 @@ mod envoy_conversions {
     };
     use orion_data_plane_api::decode::from_serde_deserializer;
     pub use orion_data_plane_api::envoy_data_plane_api::envoy::config::bootstrap::v3::Bootstrap as EnvoyBootstrap;
-    use orion_error::ResultExtension;
+    use orion_error::Context;
     use serde::Deserialize;
 
     #[derive(Deserialize)]
diff --git a/orion-configuration/src/config/log.rs b/orion-configuration/src/config/log.rs
index 5cfa9a43..301bbfb0 100644
--- a/orion-configuration/src/config/log.rs
+++ b/orion-configuration/src/config/log.rs
@@ -18,6 +18,7 @@
 //
 //
 
+use orion_error::Error;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use tracing_subscriber::EnvFilter;
 
@@ -48,7 +49,7 @@ where
     Option::<String>::deserialize(deserializer).and_then(|maybe_string| {
         maybe_string.map(|s| EnvFilter::builder().parse(s)).transpose().map_err(
             |e: tracing_subscriber::filter::ParseError| {
-                serde::de::Error::custom(format!("failed to deserialize log level because of \"{e}\""))
+                serde::de::Error::custom(Error::from(e).context("failed to parse log level config"))
             },
         )
     })
diff --git a/orion-configuration/src/main.rs b/orion-configuration/src/main.rs
index 440ab19a..6984fa9b 100644
--- a/orion-configuration/src/main.rs
+++ b/orion-configuration/src/main.rs
@@ -20,7 +20,7 @@
 //
 
 use orion_configuration::{config::Config, options::Options, Result};
-use orion_error::ResultExtension;
+use orion_error::Context;
 
 fn main() -> Result<()> {
     let config = Config::new(&Options::from_path("bootstrap.yaml"))?;
diff --git a/orion-error/src/lib.rs b/orion-error/src/lib.rs
index 48adce77..fd34f447 100644
--- a/orion-error/src/lib.rs
+++ b/orion-error/src/lib.rs
@@ -54,7 +54,7 @@ impl Display for Error {
 impl Error {
     #[must_use]
     pub fn context<T: Into<Cow<'static, str>>>(self, msg: T) -> Self {
-        Self(ErrorImpl::Msg(msg.into(), self.0.into()))
+        Self(ErrorImpl::Msg(msg.into(), self.0.into_boxed_err()))
     }
 
     pub fn inner(self) -> impl ErrorTrait + Send + Sync + 'static {
@@ -95,6 +95,16 @@ enum ErrorImpl {
     Msg(Cow<'static, str>, BoxedErr),
 }
 
+impl ErrorImpl {
+    fn into_boxed_err(self) -> BoxedErr {
+        if let Self::Error(boxed) = self {
+            boxed
+        } else {
+            self.into()
+        }
+    }
+}
+
 impl ErrorTrait for ErrorImpl {
     fn source(&self) -> Option<&(dyn ErrorTrait + 'static)> {
         match self {
@@ -140,37 +150,25 @@ impl Display for ErrorImpl {
     }
 }
 
-// alows for doing error.context("some description") on any error
-pub trait ErrorExtension {
-    #[must_use]
-    fn context<T: Into<Cow<'static, str>>>(self, context: T) -> Error;
-}
-
-impl<E: ErrorTrait + Send + Sync + 'static> ErrorExtension for E {
-    fn context<T: Into<Cow<'static, str>>>(self, msg: T) -> Error {
-        Error(ErrorImpl::Msg(msg.into(), self.into()))
-    }
-}
-
-// alows for doing error.context("some description") on results
-pub trait ResultExtension {
+// alows for doing error.context("some description")
+pub trait Context {
     type T;
     fn context<Msg: Into<Cow<'static, str>>>(self, context: Msg) -> Result<Self::T>;
     fn with_context<F: FnOnce() -> Msg, Msg: Into<Cow<'static, str>>>(self, context_fn: F) -> Result<Self::T>;
 }
 
-impl<T, E: ErrorTrait + Send + Sync + 'static> ResultExtension for StdResult<T, E> {
+impl<T, E: ErrorTrait + Send + Sync + 'static> Context for StdResult<T, E> {
     type T = T;
     fn context<Msg: Into<Cow<'static, str>>>(self, context: Msg) -> Result<Self::T> {
-        self.map_err(|e| e.context(context))
+        self.map_err(|e| Error::from(e).context(context))
     }
     fn with_context<F: FnOnce() -> Msg, Msg: Into<Cow<'static, str>>>(self, context_fn: F) -> Result<Self::T> {
-        self.map_err(|e| e.context(context_fn()))
+        self.map_err(|e| Error::from(e).context(context_fn()))
     }
 }
 
 // Error does not implement the ErrorTrait, so the previous impl does not apply to it
-impl<T> ResultExtension for Result<T> {
+impl<T> Context for Result<T> {
     type T = T;
     fn context<Msg: Into<Cow<'static, str>>>(self, context: Msg) -> Result<Self::T> {
         self.map_err(|e| e.context(context))
@@ -179,3 +177,13 @@ impl<T> ResultExtension for Result<T> {
         self.map_err(|e| e.context(context_fn()))
     }
 }
+
+impl<T> Context for Option<T> {
+    type T = T;
+    fn context<C: Into<Cow<'static, str>>>(self, msg: C) -> Result<Self::T> {
+        self.ok_or_else(|| Error::from(msg.into()))
+    }
+    fn with_context<F: FnOnce() -> C, C: Into<Cow<'static, str>>>(self, context_fn: F) -> Result<Self::T> {
+        self.ok_or_else(|| Error::from(context_fn().into()))
+    }
+}
diff --git a/orion-lib/src/listeners/http_connection_manager/redirect.rs b/orion-lib/src/listeners/http_connection_manager/redirect.rs
index a9e86069..bcedc269 100644
--- a/orion-lib/src/listeners/http_connection_manager/redirect.rs
+++ b/orion-lib/src/listeners/http_connection_manager/redirect.rs
@@ -29,7 +29,7 @@ use hyper::{body::Incoming, Request, Response};
 use orion_configuration::config::network_filters::http_connection_manager::route::{
     AuthorityRedirect, RedirectAction, RouteMatchResult,
 };
-use orion_error::ResultExtension;
+use orion_error::Context;
 use std::str::FromStr;
 
 impl RequestHandler<(Request<TimeoutBody<Incoming>>, RouteMatchResult)> for &RedirectAction {
diff --git a/orion-lib/src/listeners/http_connection_manager/route.rs b/orion-lib/src/listeners/http_connection_manager/route.rs
index 6888440d..af53d650 100644
--- a/orion-lib/src/listeners/http_connection_manager/route.rs
+++ b/orion-lib/src/listeners/http_connection_manager/route.rs
@@ -32,7 +32,7 @@ use orion_configuration::config::network_filters::http_connection_manager::{
     route::{RouteAction, RouteMatchResult},
     VirtualHost,
 };
-use orion_error::ResultExtension;
+use orion_error::Context;
 use std::net::SocketAddr;
 use tracing::debug;
 
diff --git a/orion-proxy/src/proxy.rs b/orion-proxy/src/proxy.rs
index 28be9476..266c20bd 100644
--- a/orion-proxy/src/proxy.rs
+++ b/orion-proxy/src/proxy.rs
@@ -25,7 +25,7 @@ use crate::{
 };
 use futures::future::join_all;
 use orion_configuration::config::{bootstrap::Node, Bootstrap};
-use orion_error::ResultExtension;
+use orion_error::Context;
 use orion_lib::{
     get_listeners_and_clusters, new_configuration_channel, runtime_config, ConfigurationReceivers,
     ConfigurationSenders, ListenerConfigurationChange, Result, SecretManager,

From 6af16c9569b4056745493f870a2090c2e7c752b1 Mon Sep 17 00:00:00 2001
From: Alan Keane <alan.keane1@huawei.com>
Date: Mon, 3 Mar 2025 10:36:26 +0000
Subject: [PATCH 06/64] Fix NACK not sent for malformed xDS messages with
 decoding errors

Signed-off-by: Alan Keane <alan.keane1@huawei.com>
---
 orion-xds/src/xds/client.rs | 163 ++++++++++++++++++++----------------
 1 file changed, 93 insertions(+), 70 deletions(-)

diff --git a/orion-xds/src/xds/client.rs b/orion-xds/src/xds/client.rs
index c02dcc7d..ac65d56a 100644
--- a/orion-xds/src/xds/client.rs
+++ b/orion-xds/src/xds/client.rs
@@ -343,79 +343,94 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
         let nonce = response.nonce.clone();
         info!(type_url = type_url.to_string(), size = response.resources.len(), "received config resources from xDS");
 
-        let (updates, mut pending_update_versions) = Self::map_updates(state, response, type_url);
-        let (internal_ack_tx, internal_ack_rx) = oneshot::channel::<Vec<RejectedConfig>>();
-        let notification = XdsUpdateEvent { updates, ack_channel: internal_ack_tx };
-        self.resources_tx
-            .send(notification)
-            .await
-            .map_err(|e: mpsc::error::SendError<XdsUpdateEvent>| XdsError::InternalProcessingError(e.to_string()))?;
-
-        tokio::select! {
-            ack = internal_ack_rx => {
-                match ack {
-                    Ok(rejected_configs) => {
-                        let error = if rejected_configs.is_empty() {
-                            debug!(
-                                type_url = type_url.to_string(),
-                                nonce,
-                                "sending ack response after processing",
-                            );
-                            let tracked_resources = state.tracked.entry(type_url).or_default();
-                            for (resource_id, resource_version) in pending_update_versions.drain() {
-                                tracked_resources.insert(resource_id, resource_version);
-                            }
-                            None
-                        } else {
-                            let error = rejected_configs
-                                    .into_iter()
-                                    .map(|reject| reject.to_string())
-                                    .collect::<Vec<String>>()
-                                    .join("; ");
-                            debug!(
-                                type_url = type_url.to_string(),
-                                error,
-                                nonce,
-                                "rejecting configs with nack response",
-                            );
-                            Some(Status {
-                                message: error,
-                                code: tonic::Code::InvalidArgument.into(),
+        let (updates, mut pending_update_versions, decoding_errors) = Self::map_updates(state, response, type_url);
+
+        if decoding_errors.is_empty() {
+            let (internal_ack_tx, internal_ack_rx) = oneshot::channel::<Vec<RejectedConfig>>();
+            let notification = XdsUpdateEvent { updates, ack_channel: internal_ack_tx };
+            self.resources_tx.send(notification).await.map_err(|e: mpsc::error::SendError<XdsUpdateEvent>| {
+                XdsError::InternalProcessingError(e.to_string())
+            })?;
+            tokio::select! {
+                ack = internal_ack_rx => {
+                    match ack {
+                        Ok(rejected_configs) => {
+                            let error = if rejected_configs.is_empty() {
+                                debug!(
+                                    type_url = type_url.to_string(),
+                                    nonce,
+                                    "sending ack response after processing",
+                                );
+                                let tracked_resources = state.tracked.entry(type_url).or_default();
+                                for (resource_id, resource_version) in pending_update_versions.drain() {
+                                    tracked_resources.insert(resource_id, resource_version);
+                                }
+                                None
+                            } else {
+                                let error = rejected_configs
+                                        .into_iter()
+                                        .map(|reject| reject.to_string())
+                                        .collect::<Vec<String>>()
+                                        .join("; ");
+                                debug!(
+                                    type_url = type_url.to_string(),
+                                    error,
+                                    nonce,
+                                    "rejecting configs with nack response",
+                                );
+                                Some(Status {
+                                    message: error,
+                                    code: tonic::Code::InvalidArgument.into(),
+                                    ..Default::default()
+                                })
+                            };
+                            if let Err(err) = acknowledgments_tx.send(DeltaDiscoveryRequest {
+                                type_url: type_url.to_string(),
+                                response_nonce: nonce,
+                                error_detail: error,
                                 ..Default::default()
-                            })
-                        };
-                        if let Err(err) = acknowledgments_tx.send(DeltaDiscoveryRequest {
-                            type_url: type_url.to_string(),
-                            response_nonce: nonce,
-                            error_detail: error,
+                            }).await {
+                                warn!("error in send xDS ack/nack upstream {:?}", err);
+                            }
+                        },
+                        Err(err) => {
+                            warn!("error in reading internal ack/nack {:?}", err);
+                        },
+                    }
+                }
+                () = time::sleep(ACK_TIMEOUT) => {
+                    warn!("timed out while waiting to acknowledge config updates");
+                    let error = pending_update_versions.into_keys()
+                            .collect::<Vec<String>>()
+                            .join("; ");
+                    let _ = acknowledgments_tx.send(DeltaDiscoveryRequest {
+                        type_url: type_url.to_string(),
+                        response_nonce: nonce,
+                        error_detail: Some(Status {
+                            message: error,
                             ..Default::default()
-                        })
-                        .await
-                        {
-                            warn!("error in send xDS ack/nack upstream {:?}", err);
-                        }
-                    },
-                    Err(err) => {
-                        warn!("error in reading internal ack/nack {:?}", err);
-                    },
+                        }),
+                        ..Default::default()
+                    }).await;
                 }
             }
-            () = time::sleep(ACK_TIMEOUT) => {
-                warn!("timed out while waiting to acknowledge config updates");
-                let error = pending_update_versions.into_keys()
-                        .collect::<Vec<String>>()
-                        .join("; ");
-                let error = Status {
-                    message: error,
-                    ..Default::default()
-                };
-                let _ = acknowledgments_tx.send(DeltaDiscoveryRequest {
+        } else {
+            let error =
+                decoding_errors.into_iter().map(|reject| reject.to_string()).collect::<Vec<String>>().join("; ");
+            if let Err(err) = acknowledgments_tx
+                .send(DeltaDiscoveryRequest {
                     type_url: type_url.to_string(),
-                        response_nonce: nonce,
-                        error_detail: Some(error),
+                    response_nonce: nonce,
+                    error_detail: Some(Status {
+                        message: error,
+                        code: tonic::Code::InvalidArgument.into(),
                         ..Default::default()
-                    })
-                    .await;
+                    }),
+                    ..Default::default()
+                })
+                .await
+            {
+                warn!("error in send xDS ack/nack upstream {:?}", err);
             }
         }
 
@@ -426,7 +441,7 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
         state: &mut DiscoveryClientState,
         response: DeltaDiscoveryResponse,
         type_url: TypeUrl,
-    ) -> (Vec<XdsResourceUpdate>, HashMap<String, String>) {
+    ) -> (Vec<XdsResourceUpdate>, HashMap<String, String>, Vec<RejectedConfig>) {
         let for_removal: Vec<String> = response
             .removed_resources
             .iter()
@@ -440,6 +455,7 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
             .collect();
 
         let mut pending_update_versions = HashMap::<ResourceId, ResourceVersion>::new();
+        let mut decoding_errors = Vec::<RejectedConfig>::new();
 
         let updates = response
             .resources
@@ -449,7 +465,14 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
                 let resource_version = resource.version.clone();
                 let decoded = XdsResourcePayload::try_from((resource, type_url));
                 if decoded.is_err() {
-                    warn!("problem decoding config update for {} : error {:?}", resource_id, decoded.as_ref().err());
+                    let error_msg = format!(
+                        "problem decoding config update for {} : error {:?}",
+                        resource_id,
+                        decoded.as_ref().err()
+                    );
+                    let decoding_error: orion_error::Error = error_msg.clone().into();
+                    decoding_errors.push(RejectedConfig::from((resource_id.clone(), decoding_error)));
+                    warn!(error_msg);
                 } else {
                     pending_update_versions.insert(resource_id.clone(), resource_version);
                     debug!("decoded config update for resource {resource_id}");
@@ -459,6 +482,6 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
             .chain(for_removal.into_iter().map(|resource_id| XdsResourceUpdate::Remove(resource_id, type_url)))
             .collect();
 
-        (updates, pending_update_versions)
+        (updates, pending_update_versions, decoding_errors)
     }
 }

From aada8452fa37d57a9af37a94e3b86ede5402fa73 Mon Sep 17 00:00:00 2001
From: Alan Keane <alan.keane1@huawei.com>
Date: Tue, 4 Mar 2025 12:04:32 +0000
Subject: [PATCH 07/64] Refactor xDS client.rs to improve readability

Signed-off-by: Alan Keane <alan.keane1@huawei.com>
---
 orion-proxy/src/xds_configurator.rs |   2 +-
 orion-xds/examples/client.rs        |   2 +-
 orion-xds/src/xds/client.rs         | 327 ++++++++++++++--------------
 orion-xds/src/xds/mod.rs            |   1 +
 orion-xds/src/xds/model.rs          |   5 +-
 orion-xds/src/xds/request.rs        | 105 +++++++++
 6 files changed, 275 insertions(+), 167 deletions(-)
 create mode 100644 orion-xds/src/xds/request.rs

diff --git a/orion-proxy/src/xds_configurator.rs b/orion-proxy/src/xds_configurator.rs
index 6f0c0750..9ba0f579 100644
--- a/orion-proxy/src/xds_configurator.rs
+++ b/orion-proxy/src/xds_configurator.rs
@@ -160,7 +160,7 @@ impl XdsConfigurationHandler {
         let mut rejected_updates = Vec::new();
         for update in updates {
             match update {
-                XdsResourceUpdate::Update(id, resource) => {
+                XdsResourceUpdate::Update(id, resource, _) => {
                     if let Err(e) = self.process_update_event(&id, resource).await {
                         rejected_updates.push(RejectedConfig::from((id, e)));
                     }
diff --git a/orion-xds/examples/client.rs b/orion-xds/examples/client.rs
index 858f20b6..f149915e 100644
--- a/orion-xds/examples/client.rs
+++ b/orion-xds/examples/client.rs
@@ -33,7 +33,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
             for update in notification.updates {
                 match update {
-                    XdsResourceUpdate::Update(_id, resource) => match resource {
+                    XdsResourceUpdate::Update(_id, resource, _) => match resource {
                         XdsResourcePayload::Listener(_id, resource) => {
                             info!("Got update for listener {resource:#?}");
                         },
diff --git a/orion-xds/src/xds/client.rs b/orion-xds/src/xds/client.rs
index ac65d56a..94e44d45 100644
--- a/orion-xds/src/xds/client.rs
+++ b/orion-xds/src/xds/client.rs
@@ -21,14 +21,12 @@
 use super::{
     bindings,
     model::{RejectedConfig, ResourceId, ResourceVersion, TypeUrl, XdsError, XdsResourcePayload, XdsResourceUpdate},
+    request::{DeltaDiscoveryRequestBuilder, StatusBuilder},
 };
+use core::result::Result::{Err, Ok};
 use orion_configuration::config::bootstrap::Node;
 use orion_data_plane_api::envoy_data_plane_api::{
-    envoy::{
-        config::core::v3::Node as EnvoyNode,
-        service::discovery::v3::{DeltaDiscoveryRequest, DeltaDiscoveryResponse},
-    },
-    google::rpc::Status,
+    envoy::service::discovery::v3::{DeltaDiscoveryRequest, DeltaDiscoveryResponse},
     tonic,
 };
 use std::{
@@ -160,7 +158,6 @@ pub struct DeltaClientBackgroundWorker<C: bindings::TypedXdsBinding> {
 impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
     pub async fn run(&mut self) -> Result<(), XdsError> {
         let mut connection_id = 0;
-
         let mut state = DiscoveryClientState {
             backoff: INITIAL_BACKOFF,
             tracked: HashMap::new(),
@@ -190,7 +187,7 @@ impl DiscoveryClientState {
 
 impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
     async fn persistently_connect(&mut self, state: &mut DiscoveryClientState) {
-        match self.stream_resources(state).await {
+        match self.continuously_discover_resources(state).await {
             Err(ref e @ XdsError::GrpcStatus(ref status)) => {
                 let backoff = std::cmp::min(MAX_BACKOFF, state.backoff * 2);
                 let err_detail = e.to_string();
@@ -221,54 +218,27 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
         }
     }
 
-    async fn stream_resources(&mut self, state: &mut DiscoveryClientState) -> Result<(), XdsError> {
+    async fn continuously_discover_resources(&mut self, state: &mut DiscoveryClientState) -> Result<(), XdsError> {
         let (discovery_requests_tx, mut discovery_requests_rx) = mpsc::channel::<DeltaDiscoveryRequest>(100);
 
-        let resource_types = match C::type_url() {
-            Some(type_url) => vec![type_url],
-            _ => vec![
-                TypeUrl::Secret,
-                TypeUrl::ClusterLoadAssignment,
-                TypeUrl::Cluster,
-                TypeUrl::RouteConfiguration,
-                TypeUrl::Listener,
-            ],
-        };
-        let initial_requests: Vec<DeltaDiscoveryRequest> = resource_types
-            .iter()
-            .map(|resource_type| {
-                let subscriptions = state.subscriptions.get(resource_type).cloned().unwrap_or_default();
-                let already_tracked: HashMap<ResourceId, ResourceVersion> =
-                    state.tracked.get(resource_type).cloned().unwrap_or_default();
-                DeltaDiscoveryRequest {
-                    node: Some(EnvoyNode { id: self.node.id.clone().into_string(), ..Default::default() }),
-                    type_url: resource_type.to_string(),
-                    initial_resource_versions: already_tracked,
-                    resource_names_subscribe: subscriptions.into_iter().collect(),
-                    ..Default::default()
-                }
-            })
-            .collect();
-
-        let outbound_requests = async_stream::stream! {
+        let initial_requests = self.build_initial_discovery_requests(state);
+        let outbound_request_stream = async_stream::stream! {
             for request in initial_requests {
-                info!(
-                    "sending initial discovery request {request:?}",
-                );
-
+                info!("sending initial discovery request {request:?}");
                 yield request;
             }
             while let Some(message) = discovery_requests_rx.recv().await {
-                info!(
-                    "sending subsequent discovery request {message:?}",
-                );
+                info!("sending upstream xDS message {message:?}");
                 yield message
             }
             warn!("outbound discovery request stream has ended!");
         };
-
-        let mut response_stream =
-            self.client_binding.delta_request(outbound_requests).await.map_err(XdsError::GrpcStatus)?.into_inner();
+        let mut inbound_response_stream = self
+            .client_binding
+            .delta_request(outbound_request_stream)
+            .await
+            .map_err(XdsError::GrpcStatus)?
+            .into_inner();
         info!("xDS stream established");
         state.reset_backoff();
 
@@ -277,13 +247,13 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
                 Some(event) = self.subscriptions_rx.recv() => {
                     self.process_subscription_event(event, state, &discovery_requests_tx).await;
                 }
-                discovered = response_stream.message() => {
+                discovered = inbound_response_stream.message() => {
                     let payload = discovered?;
                     let discovery_response = payload.ok_or(XdsError::UnknownResourceType("empty payload received".to_owned()))?;
-                    self.process_and_acknowledge(discovery_response, &discovery_requests_tx, state).await?;
+                    self.process_discovery_response(discovery_response, &discovery_requests_tx, state).await?;
                 },
                 else => {
-                    warn!("All channels are closed...exiting");
+                    warn!("xDS channels are closed...exiting");
                     return Ok(())
                 }
             }
@@ -302,12 +272,12 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
                 let is_new = state.subscriptions.entry(type_url).or_default().insert(resource_id.clone());
                 if is_new {
                     if let Err(err) = discovery_requests_tx
-                        .send(DeltaDiscoveryRequest {
-                            node: Some(EnvoyNode { id: self.node.id.clone().into_string(), ..Default::default() }),
-                            type_url: type_url.to_string(),
-                            resource_names_subscribe: vec![resource_id],
-                            ..Default::default()
-                        })
+                        .send(
+                            DeltaDiscoveryRequestBuilder::for_resource(type_url)
+                                .with_node_id(self.node.id.clone().to_string())
+                                .with_resource_names_subscribe(vec![resource_id])
+                                .build(),
+                        )
                         .await
                     {
                         warn!("problems updating subscription: {:?}", err);
@@ -319,12 +289,12 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
                 let was_subscribed = state.subscriptions.entry(type_url).or_default().remove(resource_id.as_str());
                 if was_subscribed {
                     if let Err(err) = discovery_requests_tx
-                        .send(DeltaDiscoveryRequest {
-                            node: Some(EnvoyNode { id: self.node.id.clone().into_string(), ..Default::default() }),
-                            type_url: type_url.to_string(),
-                            resource_names_unsubscribe: vec![resource_id],
-                            ..Default::default()
-                        })
+                        .send(
+                            DeltaDiscoveryRequestBuilder::for_resource(type_url)
+                                .with_node_id(self.node.id.clone().to_string())
+                                .with_resource_names_unsubscribe(vec![resource_id])
+                                .build(),
+                        )
                         .await
                     {
                         warn!("problems updating subscription: {:?}", err);
@@ -333,7 +303,8 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
             },
         }
     }
-    async fn process_and_acknowledge(
+
+    async fn process_discovery_response(
         &mut self,
         response: DeltaDiscoveryResponse,
         acknowledgments_tx: &mpsc::Sender<DeltaDiscoveryRequest>,
@@ -342,107 +313,124 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
         let type_url = TypeUrl::try_from(response.type_url.as_str())?;
         let nonce = response.nonce.clone();
         info!(type_url = type_url.to_string(), size = response.resources.len(), "received config resources from xDS");
-
-        let (updates, mut pending_update_versions, decoding_errors) = Self::map_updates(state, response, type_url);
-
-        if decoding_errors.is_empty() {
-            let (internal_ack_tx, internal_ack_rx) = oneshot::channel::<Vec<RejectedConfig>>();
-            let notification = XdsUpdateEvent { updates, ack_channel: internal_ack_tx };
-            self.resources_tx.send(notification).await.map_err(|e: mpsc::error::SendError<XdsUpdateEvent>| {
-                XdsError::InternalProcessingError(e.to_string())
-            })?;
-            tokio::select! {
-                ack = internal_ack_rx => {
-                    match ack {
-                        Ok(rejected_configs) => {
-                            let error = if rejected_configs.is_empty() {
-                                debug!(
-                                    type_url = type_url.to_string(),
-                                    nonce,
-                                    "sending ack response after processing",
-                                );
-                                let tracked_resources = state.tracked.entry(type_url).or_default();
-                                for (resource_id, resource_version) in pending_update_versions.drain() {
-                                    tracked_resources.insert(resource_id, resource_version);
-                                }
-                                None
-                            } else {
-                                let error = rejected_configs
-                                        .into_iter()
-                                        .map(|reject| reject.to_string())
-                                        .collect::<Vec<String>>()
-                                        .join("; ");
-                                debug!(
-                                    type_url = type_url.to_string(),
-                                    error,
-                                    nonce,
-                                    "rejecting configs with nack response",
-                                );
-                                Some(Status {
-                                    message: error,
-                                    code: tonic::Code::InvalidArgument.into(),
-                                    ..Default::default()
-                                })
-                            };
-                            if let Err(err) = acknowledgments_tx.send(DeltaDiscoveryRequest {
-                                type_url: type_url.to_string(),
-                                response_nonce: nonce,
-                                error_detail: error,
-                                ..Default::default()
-                            }).await {
-                                warn!("error in send xDS ack/nack upstream {:?}", err);
-                            }
-                        },
-                        Err(err) => {
-                            warn!("error in reading internal ack/nack {:?}", err);
-                        },
+        let for_removal = Self::process_resource_ids_for_removal(state, &response, type_url);
+
+        match Self::decode_pending_updates(&response, type_url) {
+            Ok(mut decoded_updates) => {
+                let (internal_ack_tx, internal_ack_rx) = oneshot::channel::<Vec<RejectedConfig>>();
+
+                let mut pending_update_versions = Self::extract_update_versions(&decoded_updates);
+                let mut removal_notifications = for_removal
+                    .iter()
+                    .map(|resource_id| XdsResourceUpdate::Remove(resource_id.to_string(), type_url))
+                    .collect::<Vec<XdsResourceUpdate>>();
+
+                let mut batched_updates = Vec::<XdsResourceUpdate>::new();
+                batched_updates.append(&mut decoded_updates);
+                batched_updates.append(&mut removal_notifications);
+                let batch_notification = XdsUpdateEvent { updates: batched_updates, ack_channel: internal_ack_tx };
+                self.resources_tx.send(batch_notification).await.map_err(
+                    |e: mpsc::error::SendError<XdsUpdateEvent>| XdsError::InternalProcessingError(e.to_string()),
+                )?;
+
+                tokio::select! {
+                    ack = internal_ack_rx => {
+                        match ack {
+                            Ok(rejected_configs) => {
+                                let maybe_error = if rejected_configs.is_empty() {
+                                    debug!(type_url = type_url.to_string(), nonce, "sending ack response after processing");
+                                    let tracked_resources = state.tracked.entry(type_url).or_default();
+                                    for (resource_id, resource_version) in pending_update_versions.drain() {
+                                        tracked_resources.insert(resource_id, resource_version);
+                                    }
+                                    None
+                                } else {
+                                    let error_msg = rejected_configs.into_iter()
+                                            .map(|reject| reject.to_string())
+                                            .collect::<Vec<String>>()
+                                            .join("; ");
+                                    warn!(type_url = type_url.to_string(), error_msg, nonce, "rejecting configs with nack response");
+                                    Some(StatusBuilder::invalid_argument().with_message(error_msg).build())
+                                };
+                                let upstream_response = DeltaDiscoveryRequestBuilder::for_resource(type_url)
+                                    .with_nounce(nonce.clone())
+                                    .with_error_detail(maybe_error)
+                                    .build();
+                                if let Err(err) = acknowledgments_tx.send(upstream_response).await {
+                                    warn!("error in send xDS ack/nack upstream {:?}", err);
+                                };
+                            },
+                            Err(err) => {
+                                warn!("error in reading internal ack/nack {:?}", err);
+                            },
+                        }
+                    }
+                    () = time::sleep(ACK_TIMEOUT) => {
+                        warn!("timed out while waiting to acknowledge config updates");
+                        let version_info = pending_update_versions.into_keys()
+                                .collect::<Vec<String>>()
+                                .join("; ");
+                        let error_msg = format!("timed out trying to apply resource updates for [{version_info}]");
+                        let upstream_response = DeltaDiscoveryRequestBuilder::for_resource(type_url)
+                            .with_nounce(nonce.clone())
+                            .with_error_detail(Some(StatusBuilder::unspecified_error().with_message(error_msg).build()))
+                            .build();
+                        let _ = acknowledgments_tx.send(upstream_response).await;
                     }
                 }
-                () = time::sleep(ACK_TIMEOUT) => {
-                    warn!("timed out while waiting to acknowledge config updates");
-                    let error = pending_update_versions.into_keys()
-                            .collect::<Vec<String>>()
-                            .join("; ");
-                    let _ = acknowledgments_tx.send(DeltaDiscoveryRequest {
-                        type_url: type_url.to_string(),
-                        response_nonce: nonce,
-                        error_detail: Some(Status {
-                            message: error,
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    }).await;
+            },
+
+            Err(decoding_errors) => {
+                let error_msg =
+                    decoding_errors.into_iter().map(|reject| reject.to_string()).collect::<Vec<String>>().join("; ");
+                warn!(
+                    type_url = type_url.to_string(),
+                    error_msg, nonce, "decoding error, rejecting configs with nack response"
+                );
+                let upstream_nack_response = DeltaDiscoveryRequestBuilder::for_resource(type_url)
+                    .with_nounce(nonce)
+                    .with_error_detail(Some(StatusBuilder::invalid_argument().with_message(error_msg).build()))
+                    .build();
+                if let Err(err) = acknowledgments_tx.send(upstream_nack_response).await {
+                    warn!("error in send xDS ack/nack upstream {:?}", err);
                 }
-            }
-        } else {
-            let error =
-                decoding_errors.into_iter().map(|reject| reject.to_string()).collect::<Vec<String>>().join("; ");
-            if let Err(err) = acknowledgments_tx
-                .send(DeltaDiscoveryRequest {
-                    type_url: type_url.to_string(),
-                    response_nonce: nonce,
-                    error_detail: Some(Status {
-                        message: error,
-                        code: tonic::Code::InvalidArgument.into(),
-                        ..Default::default()
-                    }),
-                    ..Default::default()
-                })
-                .await
-            {
-                warn!("error in send xDS ack/nack upstream {:?}", err);
-            }
+            },
         }
-
         Ok(())
     }
 
-    fn map_updates(
+    fn build_initial_discovery_requests(&self, tracking_state: &DiscoveryClientState) -> Vec<DeltaDiscoveryRequest> {
+        let resource_types = match C::type_url() {
+            Some(type_url) => vec![type_url],
+            _ => vec![
+                TypeUrl::Secret,
+                TypeUrl::ClusterLoadAssignment,
+                TypeUrl::Cluster,
+                TypeUrl::RouteConfiguration,
+                TypeUrl::Listener,
+            ],
+        };
+        resource_types
+            .iter()
+            .map(|resource_type| {
+                let subscriptions = tracking_state.subscriptions.get(resource_type).cloned().unwrap_or_default();
+                let already_tracked: HashMap<ResourceId, ResourceVersion> =
+                    tracking_state.tracked.get(resource_type).cloned().unwrap_or_default();
+                DeltaDiscoveryRequestBuilder::for_resource(resource_type.to_owned())
+                    .with_node_id(self.node.id.clone().to_string())
+                    .with_initial_resource_versions(already_tracked)
+                    .with_resource_names_subscribe(subscriptions.into_iter().collect())
+                    .build()
+            })
+            .collect()
+    }
+
+    fn process_resource_ids_for_removal(
         state: &mut DiscoveryClientState,
-        response: DeltaDiscoveryResponse,
+        response: &DeltaDiscoveryResponse,
         type_url: TypeUrl,
-    ) -> (Vec<XdsResourceUpdate>, HashMap<String, String>, Vec<RejectedConfig>) {
-        let for_removal: Vec<String> = response
+    ) -> Vec<String> {
+        response
             .removed_resources
             .iter()
             .map(|resource_id| {
@@ -452,13 +440,17 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
                 }
                 resource_id.clone()
             })
-            .collect();
+            .collect()
+    }
 
-        let mut pending_update_versions = HashMap::<ResourceId, ResourceVersion>::new();
+    fn decode_pending_updates(
+        response: &DeltaDiscoveryResponse,
+        type_url: TypeUrl,
+    ) -> Result<Vec<XdsResourceUpdate>, Vec<RejectedConfig>> {
         let mut decoding_errors = Vec::<RejectedConfig>::new();
-
-        let updates = response
+        let decoded_updates = response
             .resources
+            .clone()
             .into_iter()
             .filter_map(|resource| {
                 let resource_id = resource.name.clone();
@@ -473,15 +465,24 @@ impl<C: bindings::TypedXdsBinding> DeltaClientBackgroundWorker<C> {
                     let decoding_error: orion_error::Error = error_msg.clone().into();
                     decoding_errors.push(RejectedConfig::from((resource_id.clone(), decoding_error)));
                     warn!(error_msg);
-                } else {
-                    pending_update_versions.insert(resource_id.clone(), resource_version);
-                    debug!("decoded config update for resource {resource_id}");
                 }
-                decoded.ok().map(|value| XdsResourceUpdate::Update(resource_id.clone(), value))
+                decoded.ok().map(|value| XdsResourceUpdate::Update(resource_id, value, resource_version))
             })
-            .chain(for_removal.into_iter().map(|resource_id| XdsResourceUpdate::Remove(resource_id, type_url)))
             .collect();
+        if decoding_errors.is_empty() {
+            Ok(decoded_updates)
+        } else {
+            Err(decoding_errors)
+        }
+    }
 
-        (updates, pending_update_versions, decoding_errors)
+    fn extract_update_versions(updates: &[XdsResourceUpdate]) -> HashMap<ResourceId, ResourceVersion> {
+        let mut update_versions = HashMap::<ResourceId, ResourceVersion>::new();
+        for update in updates {
+            if let XdsResourceUpdate::Update(resource_id, _, resource_version) = update {
+                update_versions.insert(resource_id.to_string(), resource_version.to_string());
+            }
+        }
+        update_versions
     }
 }
diff --git a/orion-xds/src/xds/mod.rs b/orion-xds/src/xds/mod.rs
index 94b02b44..b3b74881 100644
--- a/orion-xds/src/xds/mod.rs
+++ b/orion-xds/src/xds/mod.rs
@@ -22,5 +22,6 @@ pub mod bindings;
 pub mod client;
 pub mod model;
 
+mod request;
 pub mod resources;
 pub mod server;
diff --git a/orion-xds/src/xds/model.rs b/orion-xds/src/xds/model.rs
index 5a4e9404..9b3348b9 100644
--- a/orion-xds/src/xds/model.rs
+++ b/orion-xds/src/xds/model.rs
@@ -18,6 +18,7 @@
 //
 //
 
+use core::result::Result::Err;
 use orion_configuration::config::{
     cluster::Cluster, cluster::ClusterLoadAssignment, common::GenericError, listener::Listener,
     network_filters::http_connection_manager::RouteConfiguration, secret::Secret,
@@ -48,14 +49,14 @@ pub type ResourceVersion = String;
 
 #[derive(Debug)]
 pub enum XdsResourceUpdate {
-    Update(ResourceId, XdsResourcePayload),
+    Update(ResourceId, XdsResourcePayload, ResourceVersion),
     Remove(ResourceId, TypeUrl),
 }
 
 impl XdsResourceUpdate {
     pub fn id(&self) -> ResourceId {
         match self {
-            XdsResourceUpdate::Update(id, _) | XdsResourceUpdate::Remove(id, _) => id.to_string(),
+            XdsResourceUpdate::Update(id, _, _) | XdsResourceUpdate::Remove(id, _) => id.to_string(),
         }
     }
 }
diff --git a/orion-xds/src/xds/request.rs b/orion-xds/src/xds/request.rs
new file mode 100644
index 00000000..c6fb3953
--- /dev/null
+++ b/orion-xds/src/xds/request.rs
@@ -0,0 +1,105 @@
+use super::model::{ResourceId, ResourceVersion, TypeUrl};
+use ng2_data_plane_api::envoy_data_plane_api::{
+    envoy::{config::core::v3::Node as EnvoyNode, service::discovery::v3::DeltaDiscoveryRequest},
+    google::rpc::Status,
+    tonic,
+};
+use std::collections::HashMap;
+
+pub struct StatusBuilder {
+    code: i32,
+    message: String,
+}
+
+#[allow(dead_code)]
+impl StatusBuilder {
+    pub fn unspecified_error() -> Self {
+        StatusBuilder { code: tonic::Code::Unknown.into(), message: String::new() }
+    }
+
+    pub fn invalid_argument() -> Self {
+        StatusBuilder { code: tonic::Code::InvalidArgument.into(), message: String::new() }
+    }
+
+    pub fn with_message(mut self, message: String) -> Self {
+        self.message = message;
+        self
+    }
+
+    pub fn build(self) -> Status {
+        Status { message: self.message, code: self.code, ..Default::default() }
+    }
+}
+
+pub struct DeltaDiscoveryRequestBuilder {
+    node: Option<String>,
+    nounce: Option<String>,
+    type_url: TypeUrl,
+    error_detail: Option<Status>,
+    resource_names_subscribe: Vec<ResourceId>,
+    resource_names_unsubscribe: Vec<ResourceId>,
+    initial_resource_versions: HashMap<ResourceId, ResourceVersion>,
+}
+
+#[allow(dead_code)]
+impl DeltaDiscoveryRequestBuilder {
+    pub fn for_resource(type_url: TypeUrl) -> Self {
+        DeltaDiscoveryRequestBuilder {
+            node: None,
+            nounce: None,
+            type_url,
+            error_detail: None,
+            resource_names_subscribe: Vec::new(),
+            resource_names_unsubscribe: Vec::new(),
+            initial_resource_versions: HashMap::new(),
+        }
+    }
+
+    pub fn with_node_id(mut self, node_id: String) -> Self {
+        self.node = Some(node_id);
+        self
+    }
+
+    pub fn with_nounce(mut self, nounce: String) -> Self {
+        self.nounce = Some(nounce);
+        self
+    }
+
+    pub fn with_resource_names_subscribe(mut self, resource_names: Vec<ResourceId>) -> Self {
+        self.resource_names_subscribe = resource_names;
+        self
+    }
+
+    pub fn with_resource_names_unsubscribe(mut self, resource_names: Vec<ResourceId>) -> Self {
+        self.resource_names_unsubscribe = resource_names;
+        self
+    }
+
+    pub fn with_initial_resource_versions(
+        mut self,
+        initial_resource_versions: HashMap<ResourceId, ResourceVersion>,
+    ) -> Self {
+        self.initial_resource_versions = initial_resource_versions;
+        self
+    }
+
+    pub fn with_error_detail(mut self, error_detail: Option<Status>) -> Self {
+        self.error_detail = error_detail;
+        self
+    }
+
+    pub fn build(self) -> DeltaDiscoveryRequest {
+        let node_id = self.node.unwrap_or_default();
+        let nounce = self.nounce.unwrap_or_default();
+        DeltaDiscoveryRequest {
+            node: Some(EnvoyNode { id: node_id, ..Default::default() }),
+            response_nonce: nounce,
+            type_url: self.type_url.to_string(),
+            resource_names_subscribe: self.resource_names_subscribe,
+            resource_names_unsubscribe: self.resource_names_unsubscribe,
+            initial_resource_versions: self.initial_resource_versions,
+            error_detail: self.error_detail,
+            ..Default::default()
+        }
+    }
+}

From d8c28eb2cbc559e1c47e69efa88b150ab63a8b74 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 12 May 2025 12:11:47 +0200
Subject: [PATCH 08/64] Add orion-format module with Envoy grammar and token
 parsing

Includes:
- EnvoyGrammar for parsing Envoy-style log templates
- Token definitions and argument handling
- Unit tests for various parsing scenarios

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 Cargo.lock                  |  46 ++++
 Cargo.toml                  |   4 +-
 orion-format/Cargo.toml     |  15 ++
 orion-format/src/context.rs |   0
 orion-format/src/envoy.rs   | 431 ++++++++++++++++++++++++++++++++++++
 orion-format/src/lib.rs     |  96 ++++++++
 orion-format/src/token.rs   | 149 +++++++++++++
 7 files changed, 740 insertions(+), 1 deletion(-)
 create mode 100644 orion-format/Cargo.toml
 create mode 100644 orion-format/src/context.rs
 create mode 100644 orion-format/src/envoy.rs
 create mode 100644 orion-format/src/lib.rs
 create mode 100644 orion-format/src/token.rs

diff --git a/Cargo.lock b/Cargo.lock
index c15d9778..f667a54c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1681,6 +1681,18 @@ dependencies = [
 name = "orion-error"
 version = "0.1.0"
 
+[[package]]
+name = "orion-format"
+version = "0.1.0"
+dependencies = [
+ "http",
+ "lazy_static",
+ "ptrie",
+ "strum",
+ "strum_macros",
+ "thiserror",
+]
+
 [[package]]
 name = "orion-lib"
 version = "0.1.0"
@@ -2008,6 +2020,18 @@ dependencies = [
  "prost",
 ]
 
+[[package]]
+name = "ptrie"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4debfffbf1669869b4bea1bab297f8e9ec11900a9ff2dcf659c2a1c4918c811a"
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
 [[package]]
 name = "quote"
 version = "1.0.40"
@@ -2509,6 +2533,28 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
+[[package]]
+name = "strum"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"
diff --git a/Cargo.toml b/Cargo.toml
index 32601b24..75902421 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,6 +6,7 @@ members = [
   "orion-error",
   "orion-lib",
   "orion-proxy",
+  "orion-format",
   "orion-xds",
 ]
 resolver = "2"
@@ -15,6 +16,7 @@ envoy-data-plane-api = { path = "envoy-data-plane-api" }
 orion-configuration = { path = "orion-configuration" }
 orion-data-plane-api = { path = "orion-data-plane-api" }
 orion-error = { path = "orion-error" }
+orion-format = { path = "orion-format" }
 orion-lib = { path = "orion-lib" }
 orion-xds = { path = "orion-xds" }
 
@@ -93,4 +95,4 @@ inconsistent_struct_constructor = "allow"
 semicolon-if-nothing-returned = "allow"
 missing_errors_doc      = "allow"
 must_use_candidate      = "allow"
-doc_markdown            = "allow"
\ No newline at end of file
+doc_markdown            = "allow"
diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
new file mode 100644
index 00000000..d080840a
--- /dev/null
+++ b/orion-format/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "orion-format"
+version = "0.1.0"
+edition = "2021"
+
+[lints]
+workspace = true
+
+[dependencies]
+http.workspace = true
+lazy_static = "1.5.0"
+ptrie = "0.7.2"
+strum = { version = "0.27.1", features = ["derive"] }
+strum_macros = "0.27.1"
+thiserror.workspace = true
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
new file mode 100644
index 00000000..e69de29b
diff --git a/orion-format/src/envoy.rs b/orion-format/src/envoy.rs
new file mode 100644
index 00000000..a6ab1e27
--- /dev/null
+++ b/orion-format/src/envoy.rs
@@ -0,0 +1,431 @@
+use crate::token::{ReqArg, RespArg, Token, TokenArgument};
+use crate::{FormatError, Grammar, Template};
+use http::HeaderName;
+use lazy_static::lazy_static;
+use ptrie::Trie;
+
+macro_rules! trie_mapstr {
+    ($trie:expr, $lit:literal, $tok:expr) => {
+        $trie.insert($lit.bytes(), ($tok, $lit.len(), false)); // expand the variadic arguments into the tuple.
+    };
+    ($trie:expr, $lit:literal, $tok:expr, $arg:expr ) => {
+        $trie.insert($lit.bytes(), ($tok, $lit.len(), $arg)); // expand the variadic arguments into the tuple.
+    };
+}
+
+lazy_static! {
+    static ref ENVOY_REQ_ARGS: Trie<u8, (ReqArg, usize, bool)> = {
+        let mut trie = Trie::new();
+        trie_mapstr!(trie, ":SCHEME",ReqArg::Scheme);
+        trie_mapstr!(trie, ":METHOD",ReqArg::Method);
+        trie_mapstr!(trie, ":PATH", ReqArg::Path);
+        trie_mapstr!(trie, ":AUTHORITY",ReqArg::Authority);
+        trie
+    };
+
+    static ref ENVOY_RESP_ARGS: Trie<u8, (RespArg, usize, bool)> = {
+        let trie = Trie::new();
+        trie
+    };
+
+    static ref ENVOY_PATTERNS: Trie<u8, (Token, usize, bool)> = {
+        let mut trie = Trie::new();
+        trie_mapstr!(trie, "REQUEST_DURATION", Token::RequestDuration);
+        trie_mapstr!(trie, "REQUEST_TX_DURATION", Token::RequestTxDuration);
+        trie_mapstr!(trie, "RESPONSE_DURATION", Token::ResponseDuration);
+        trie_mapstr!(trie, "RESPONSE_TX_DURATION", Token::ResponseTxDuration);
+        trie_mapstr!(trie, "DOWNSTREAM_HANDSHAKE_DURATION", Token::DownstreamHandshakeDuration);
+        trie_mapstr!(trie, "ROUNDTRIP_DURATION", Token::RoundtripDuration);
+        trie_mapstr!(trie, "BYTES_RECEIVED", Token::BytesReceived);
+        trie_mapstr!(trie, "BYTES_RETRANSMITTED", Token::BytesRetransmitted);
+        trie_mapstr!(trie, "PACKETS_RETRANSMITTED", Token::PacketsRetransmitted);
+        trie_mapstr!(trie, "UPSTREAM_WIRE_BYTES_RECEIVED", Token::UpstreamWireBytesReceived);
+        trie_mapstr!(trie, "UPSTREAM_HEADER_BYTES_RECEIVED", Token::UpstreamHeaderBytesReceived);
+        trie_mapstr!(trie, "DOWNSTREAM_WIRE_BYTES_RECEIVED", Token::DownstreamWireBytesReceived);
+        trie_mapstr!(trie, "DOWNSTREAM_HEADER_BYTES_RECEIVED", Token::DownstreamHeaderBytesReceived);
+        trie_mapstr!(trie, "PROTOCOL", Token::Protocol);
+        trie_mapstr!(trie, "UPSTREAM_PROTOCOL", Token::UpstreamProtocol);
+        trie_mapstr!(trie, "RESPONSE_CODE", Token::ResponseCode);
+        trie_mapstr!(trie, "RESPONSE_CODE_DETAILS", Token::ResponseCodeDetails);
+        trie_mapstr!(trie, "CONNECTION_TERMINATION_DETAILS", Token::ConnectionTerminationDetails);
+        trie_mapstr!(trie, "BYTES_SENT", Token::BytesSent);
+        trie_mapstr!(trie, "UPSTREAM_WIRE_BYTES_SENT", Token::UpstreamWireBytesSent);
+        trie_mapstr!(trie, "UPSTREAM_HEADER_BYTES_SENT", Token::UpstreamHeaderBytesSent);
+        trie_mapstr!(trie, "DOWNSTREAM_WIRE_BYTES_SENT", Token::DownstreamWireBytesSent);
+        trie_mapstr!(trie, "DOWNSTREAM_HEADER_BYTES_SENT", Token::DownstreamHeaderBytesSent);
+        trie_mapstr!(trie, "DURATION", Token::Duration);
+        trie_mapstr!(trie, "COMMON_DURATION", Token::CommonDuration);
+        trie_mapstr!(trie, "CUSTOM_FLAGS", Token::CustomFlags);
+        trie_mapstr!(trie, "RESPONSE_FLAGS", Token::ResponseFlags);
+        trie_mapstr!(trie, "RESPONSE_FLAGS_LONG", Token::ResponseFlagsLong);
+        trie_mapstr!(trie, "UPSTREAM_HOST_NAME", Token::UpstreamHostName);
+        trie_mapstr!(trie, "UPSTREAM_HOST_NAME_WITHOUT_PORT", Token::UpstreamHostNameWithoutPort);
+        trie_mapstr!(trie, "UPSTREAM_HOST", Token::UpstreamHost);
+        trie_mapstr!(trie, "UPSTREAM_CONNECTION_ID", Token::UpstreamConnectionId);
+        trie_mapstr!(trie, "UPSTREAM_CLUSTER", Token::UpstreamCluster);
+        trie_mapstr!(trie, "UPSTREAM_CLUSTER_RAW", Token::UpstreamClusterRaw);
+        trie_mapstr!(trie, "UPSTREAM_LOCAL_ADDRESS", Token::UpstreamLocalAddress);
+        trie_mapstr!(trie, "UPSTREAM_LOCAL_ADDRESS_WITHOUT_PORT", Token::UpstreamLocalAddressWithoutPort);
+        trie_mapstr!(trie, "UPSTREAM_LOCAL_PORT", Token::UpstreamLocalPort);
+        trie_mapstr!(trie, "UPSTREAM_REMOTE_ADDRESS", Token::UpstreamRemoteAddress);
+        trie_mapstr!(trie, "UPSTREAM_REMOTE_ADDRESS_WITHOUT_PORT", Token::UpstreamRemoteAddressWithoutPort);
+        trie_mapstr!(trie, "UPSTREAM_REMOTE_PORT", Token::UpstreamRemotePort);
+        trie_mapstr!(trie, "UPSTREAM_REQUEST_ATTEMPT_COUNT", Token::UpstreamRequestAttemptCount);
+        trie_mapstr!(trie, "UPSTREAM_TLS_CIPHER", Token::UpstreamTlsCipher);
+        trie_mapstr!(trie, "UPSTREAM_TLS_VERSION", Token::UpstreamTlsVersion);
+        trie_mapstr!(trie, "UPSTREAM_TLS_SESSION_ID", Token::UpstreamTlsSessionId);
+        trie_mapstr!(trie, "UPSTREAM_PEER_ISSUER", Token::UpstreamPeerIssuer);
+        trie_mapstr!(trie, "UPSTREAM_PEER_CERT", Token::UpstreamPeerCert);
+        trie_mapstr!(trie, "UPSTREAM_PEER_SUBJECT", Token::UpstreamPeerSubject);
+        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_ADDRESS", Token::DownstreamLocalAddress);
+        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_LOCAL_ADDRESS", Token::DownstreamDirectLocalAddress);
+        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_ADDRESS_WITHOUT_PORT", Token::DownstreamLocalAddressWithoutPort);
+        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_LOCAL_ADDRESS_WITHOUT_PORT", Token::DownstreamDirectLocalAddressWithoutPort);
+        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_PORT", Token::DownstreamLocalPort);
+        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_LOCAL_PORT", Token::DownstreamDirectLocalPort);
+        trie_mapstr!(trie, "DOWNSTREAM_REMOTE_ADDRESS", Token::DownstreamRemoteAddress);
+        trie_mapstr!(trie, "DOWNSTREAM_REMOTE_ADDRESS_WITHOUT_PORT", Token::DownstreamRemoteAddressWithoutPort);
+        trie_mapstr!(trie, "DOWNSTREAM_REMOTE_PORT", Token::DownstreamRemotePort);
+        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_REMOTE_ADDRESS", Token::DownstreamDirectRemoteAddress);
+        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_REMOTE_ADDRESS_WITHOUT_PORT", Token::DownstreamDirectRemoteAddressWithoutPort);
+        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_REMOTE_PORT", Token::DownstreamDirectRemotePort);
+        trie_mapstr!(trie, "CONNECTION_ID", Token::ConnectionId);
+        trie_mapstr!(trie, "REQUESTED_SERVER_NAME", Token::RequestedServerName);
+        trie_mapstr!(trie, "ROUTE_NAME", Token::RouteName);
+        trie_mapstr!(trie, "UPSTREAM_PEER_URI_SAN", Token::UpstreamPeerUriSan);
+        trie_mapstr!(trie, "UPSTREAM_PEER_DNS_SAN", Token::UpstreamPeerDnsSan);
+        trie_mapstr!(trie, "UPSTREAM_PEER_IP_SAN", Token::UpstreamPeerIpSan);
+        trie_mapstr!(trie, "UPSTREAM_LOCAL_URI_SAN", Token::UpstreamLocalUriSan);
+        trie_mapstr!(trie, "UPSTREAM_LOCAL_DNS_SAN", Token::UpstreamLocalDnsSan);
+        trie_mapstr!(trie, "UPSTREAM_LOCAL_IP_SAN", Token::UpstreamLocalIpSan);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_URI_SAN", Token::DownstreamPeerUriSan);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_DNS_SAN", Token::DownstreamPeerDnsSan);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_IP_SAN", Token::DownstreamPeerIpSan);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_EMAIL_SAN", Token::DownstreamPeerEmailSan);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_OTHERNAME_SAN", Token::DownstreamPeerOthernameSan);
+        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_URI_SAN", Token::DownstreamLocalUriSan);
+        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_DNS_SAN", Token::DownstreamLocalDnsSan);
+        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_IP_SAN", Token::DownstreamLocalIpSan);
+        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_EMAIL_SAN", Token::DownstreamLocalEmailSan);
+        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_OTHERNAME_SAN", Token::DownstreamLocalOthernameSan);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_SUBJECT", Token::DownstreamPeerSubject);
+        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_SUBJECT", Token::DownstreamLocalSubject);
+        trie_mapstr!(trie, "DOWNSTREAM_TLS_SESSION_ID", Token::DownstreamTlsSessionId);
+        trie_mapstr!(trie, "DOWNSTREAM_TLS_CIPHER", Token::DownstreamTlsCipher);
+        trie_mapstr!(trie, "DOWNSTREAM_TLS_VERSION", Token::DownstreamTlsVersion);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_FINGERPRINT_256", Token::DownstreamPeerFingerprint256);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_FINGERPRINT_1", Token::DownstreamPeerFingerprint1);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_SERIAL", Token::DownstreamPeerSerial);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_CHAIN_FINGERPRINTS_256", Token::DownstreamPeerChainFingerprints256);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_CHAIN_FINGERPRINTS_1", Token::DownstreamPeerChainFingerprints1);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_CHAIN_SERIALS", Token::DownstreamPeerChainSerials);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_ISSUER", Token::DownstreamPeerIssuer);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_CERT", Token::DownstreamPeerCert);
+        trie_mapstr!(trie, "DOWNSTREAM_TRANSPORT_FAILURE_REASON", Token::DownstreamTransportFailureReason);
+        trie_mapstr!(trie, "UPSTREAM_TRANSPORT_FAILURE_REASON", Token::UpstreamTransportFailureReason);
+        trie_mapstr!(trie, "HOSTNAME", Token::Hostname);
+        trie_mapstr!(trie, "FILTER_CHAIN_NAME", Token::FilterChainName);
+        trie_mapstr!(trie, "VIRTUAL_CLUSTER_NAME", Token::VirtualClusterName);
+        trie_mapstr!(trie, "TLS_JA3_FINGERPRINT", Token::TlsJa3Fingerprint);
+        trie_mapstr!(trie, "UNIQUE_ID", Token::UniqueId);
+        trie_mapstr!(trie, "STREAM_ID", Token::StreamId);
+        trie_mapstr!(trie, "START_TIME", Token::StartTime);
+        trie_mapstr!(trie, "START_TIME_LOCAL", Token::StartTimeLocal);
+        trie_mapstr!(trie, "EMIT_TIME", Token::EmitTime);
+        trie_mapstr!(trie, "EMIT_TIME_LOCAL", Token::EmitTimeLocal);
+        trie_mapstr!(trie, "DYNAMIC_METADATA", Token::DynamicMetadata);
+        trie_mapstr!(trie, "CLUSTER_METADATA", Token::ClusterMetadata);
+        trie_mapstr!(trie, "UPSTREAM_METADATA", Token::UpstreamMetadata);
+        trie_mapstr!(trie, "FILTER_STATE", Token::FilterState);
+        trie_mapstr!(trie, "UPSTREAM_FILTER_STATE", Token::UpstreamFilterState);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_CERT_V_START", Token::DownstreamPeerCertVStart);
+        trie_mapstr!(trie, "DOWNSTREAM_PEER_CERT_V_END", Token::DownstreamPeerCertVEnd);
+        trie_mapstr!(trie, "UPSTREAM_PEER_CERT_V_START", Token::UpstreamPeerCertVStart);
+        trie_mapstr!(trie, "UPSTREAM_PEER_CERT_V_END", Token::UpstreamPeerCertVEnd);
+        trie_mapstr!(trie, "ENVIRONMENT", Token::Environment);
+        trie_mapstr!(trie, "UPSTREAM_CONNECTION_POOL_READY_DURATION", Token::UpstreamConnectionPoolReadyDuration);
+        trie_mapstr!(trie, "REQ", Token::Request, true); // %REQ(USER-AGENT)%
+        trie_mapstr!(trie, "RESP", Token::Response, true); // %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)%
+        trie
+    };
+}
+
+pub struct EnvoyGrammar;
+
+impl EnvoyGrammar {
+    fn parse_request(arg: &str) -> Result<ReqArg, FormatError> {
+        match ENVOY_REQ_ARGS.find_longest_prefix(arg.bytes()) {
+            Some((t, _, _)) => Ok(t.clone()),
+            None => {
+                let name =
+                    HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidRequestArg(arg.into()))?;
+                Ok(ReqArg::Header(name))
+            },
+        }
+    }
+
+    fn parse_response(arg: &str) -> Result<RespArg, FormatError> {
+        match ENVOY_RESP_ARGS.find_longest_prefix(arg.bytes()) {
+            Some((t, _, _)) => Ok(t.clone()),
+            None => {
+                let name =
+                    HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidResponseArg(arg.into()))?;
+                Ok(RespArg::Header(name))
+            },
+        }
+    }
+
+    fn extract_token_arg(input: &str) -> Result<(&str, usize), FormatError> {
+        if let Some(rest) = input.strip_prefix('(') {
+            if let Some(end) = rest.find(')') {
+                let arg = &rest[..end];
+                if arg.is_empty() {
+                    return Err(FormatError::EmptyArgument(input.into()));
+                }
+                let total_len = end + 2; // '(' + arg.len() + ')'
+                return Ok((arg, total_len));
+            }
+        }
+        Err(FormatError::MissingBracket(input.into()))
+    }
+}
+
+impl Grammar for EnvoyGrammar {
+    fn parse(input: &str) -> Result<Vec<Template>, FormatError> {
+        let mut parts = Vec::new();
+        let mut literal_start = 0; // Indice di inizio del literal corrente
+        let mut i = 0;
+
+        while i < input.len() {
+            let mut longest_placeholder: Option<(Token, usize, Option<TokenArgument>)> = None;
+            let mut skip = None;
+
+            // finst the longest placeholder starting from the current index i
+            //
+            if input[i..].starts_with("%") {
+                let remainder = &input[i + 1..];
+                if remainder.starts_with("%") {
+                    skip = Some(2);
+                } else if let Some((placeholder, placeholder_len, has_arg)) =
+                    ENVOY_PATTERNS.find_longest_prefix(remainder.bytes())
+                {
+                    let after_placeholder = &remainder[*placeholder_len..];
+                    // placeholder found
+                    if *has_arg {
+                        let (arg_value, arg_len) = Self::extract_token_arg(after_placeholder)?;
+
+                        if longest_placeholder.is_none() || *placeholder_len > longest_placeholder.as_ref().unwrap().1 {
+                            match placeholder {
+                                Token::Request => {
+                                    let arg = Self::parse_request(&arg_value)?;
+                                    longest_placeholder =
+                                        Some((*placeholder, *placeholder_len, Some(TokenArgument::Request(arg))));
+                                },
+                                Token::Response => {
+                                    let arg = Self::parse_response(&arg_value)?;
+                                    longest_placeholder =
+                                        Some((*placeholder, *placeholder_len, Some(TokenArgument::Response(arg))));
+                                },
+                                _ => (),
+                            }
+                        }
+
+                        if !after_placeholder[arg_len..].starts_with("%") {
+                            return Err(FormatError::MissingDelimiter(input[i + *placeholder_len..].into()));
+                        }
+
+                        skip = Some(2 + *placeholder_len + arg_len);
+                    } else {
+                        longest_placeholder = Some((*placeholder, *placeholder_len, None));
+                        if !after_placeholder.starts_with("%") {
+                            return Err(FormatError::MissingDelimiter(input[i + *placeholder_len..].into()));
+                        }
+                        skip = Some(2 + *placeholder_len);
+                    }
+                } else {
+                    return Err(FormatError::UnsupportedPattern(input[i..].into()));
+                }
+            }
+
+            if let Some(placeholder) = longest_placeholder.as_ref() {
+                // placeholder found
+                if i > literal_start {
+                    let literal_text = &input[literal_start..i];
+                    parts.push(Template::Literal(literal_text.to_string()));
+                }
+
+                // Add this placeholder.
+                parts.push(Template::Placeholder(placeholder.0.into(), placeholder.2.clone()));
+
+                // advnace the index beyond the current placeholder and possibly its argument.
+                i += skip.unwrap();
+
+                literal_start = i;
+            } else {
+                /* skip the specified number of bytes, or by default the next char */
+                i += skip.unwrap_or(input[i..].chars().next().map(|c| c.len_utf8()).unwrap_or(0));
+            }
+        }
+
+        // if there's some text remaning, it's a literal
+        if i > literal_start {
+            let literal_text = &input[literal_start..i];
+
+            parts.push(Template::Literal(literal_text.replace("%%", "%")));
+        }
+
+        Ok(parts)
+    }
+}
+
+// Unit tests module
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_only_literals() {
+        let input = "This is a plain literal string.";
+        let expected = vec![Template::Literal("This is a plain literal string.".into())];
+        let actual = EnvoyGrammar::parse(input).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_parse_only_placeholders() {
+        let input = "%START_TIME%%PROTOCOL%";
+        let expected =
+            vec![Template::Placeholder(Token::StartTime, None), Template::Placeholder(Token::Protocol, None)];
+        let actual = EnvoyGrammar::parse(input).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_parse_mixed_literal_and_placeholders() {
+        let input = "Start %REQ(:METHOD)% middle %PROTOCOL% end.";
+        let expected = vec![
+            Template::Literal("Start ".into()),
+            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Method))),
+            Template::Literal(" middle ".into()),
+            Template::Placeholder(Token::Protocol, None),
+            Template::Literal(" end.".into()),
+        ];
+        let actual = EnvoyGrammar::parse(input).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_parse_starts_with_placeholder() {
+        let input = "%START_TIME% literal after.";
+        let expected = vec![Template::Placeholder(Token::StartTime, None), Template::Literal(" literal after.".into())];
+        let actual = EnvoyGrammar::parse(input).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_parse_ends_with_placeholder() {
+        let input = "Literal before %PROTOCOL%";
+        let expected = vec![Template::Literal("Literal before ".into()), Template::Placeholder(Token::Protocol, None)];
+        let actual = EnvoyGrammar::parse(input).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_parse_empty_string() {
+        let input = "";
+        let expected: Vec<Template> = vec![]; // Expect an empty vector
+        let actual = EnvoyGrammar::parse(input).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_parse_with_special_chars_in_literal() {
+        let input = "Literal with \"quotes\" and %%percent signs%% not placeholders.";
+        let expected = vec![Template::Literal("Literal with \"quotes\" and %percent signs% not placeholders.".into())];
+        let actual = EnvoyGrammar::parse(input).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_parse_complex_envoy_string() {
+        let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%""#;
+        let expected = vec![
+            Template::Literal("[".into()),
+            Template::Placeholder(Token::StartTime, None),
+            Template::Literal("] \"".into()),
+            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Method))),
+            Template::Literal(" ".into()),
+            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Path))),
+            Template::Literal(" ".into()),
+            Template::Placeholder(Token::Protocol, None),
+            Template::Literal("\"".into()),
+        ];
+        let actual = EnvoyGrammar::parse(input).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    // bad patters..
+
+    #[test]
+    fn test_parse_unsupported_token() {
+        let input = "%UNSUPPORTED%";
+        let result = EnvoyGrammar::parse(input);
+        assert!(matches!(result, Err(FormatError::UnsupportedPattern(_))));
+    }
+
+    #[test]
+    fn test_parse_error_empty_argument() {
+        let input = "%REQ()%";
+        let result = EnvoyGrammar::parse(input);
+        assert!(matches!(result, Err(FormatError::EmptyArgument(_))));
+    }
+
+    #[test]
+    fn test_parse_error_missing_bracket_1() {
+        let input = "%REQ";
+        let result = EnvoyGrammar::parse(input);
+        assert!(matches!(result, Err(FormatError::MissingBracket(_))));
+    }
+
+    #[test]
+    fn test_parse_error_missing_bracket_2() {
+        let input = "%REQ(USER_AGENT%";
+        let result = EnvoyGrammar::parse(input);
+        assert!(matches!(result, Err(FormatError::MissingBracket(_))));
+    }
+
+    #[test]
+    fn test_parse_error_missing_delimiter_1() {
+        let input = "%REQUEST_DURATION";
+        let result = EnvoyGrammar::parse(input);
+        assert!(matches!(result, Err(FormatError::MissingDelimiter(_))));
+    }
+
+    #[test]
+    fn test_parse_error_missing_delimiter_2() {
+        let input = "%REQ(USER_AGENT)";
+        let result = EnvoyGrammar::parse(input);
+        assert!(matches!(result, Err(FormatError::MissingDelimiter(_))));
+    }
+
+    #[test]
+    fn test_parse_error_missing_delimiter_3() {
+        let input = "%REQ(USER_AGENT) ";
+        let result = EnvoyGrammar::parse(input);
+        assert!(matches!(result, Err(FormatError::MissingDelimiter(_))));
+    }
+
+    #[test]
+    fn test_parse_invalid_req_argument() {
+        let input = "%REQ(<BAD>)%";
+        let result = EnvoyGrammar::parse(input);
+        assert!(matches!(result, Err(FormatError::InvalidRequestArg(_))));
+    }
+
+    #[test]
+    fn test_parse_invalid_resp_argument() {
+        let input = "%RESP(<BAD>)%";
+        let result = EnvoyGrammar::parse(input);
+        assert!(matches!(result, Err(FormatError::InvalidResponseArg(_))));
+    }
+}
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
new file mode 100644
index 00000000..8c8eaf04
--- /dev/null
+++ b/orion-format/src/lib.rs
@@ -0,0 +1,96 @@
+pub mod context;
+pub mod envoy;
+pub mod token;
+
+use std::borrow::Cow;
+use std::fmt::{self, Display, Formatter};
+use thiserror::Error;
+use token::{Token, TokenArgument};
+
+use crate::envoy::EnvoyGrammar;
+
+#[derive(Error, Debug)]
+pub enum FormatError {
+    #[error("pattern `{0}` not supported")]
+    UnsupportedPattern(String),
+    #[error("missing argument for `{0}`")]
+    MissingArgument(String),
+    #[error("missing braket around `{0}`...")]
+    MissingBracket(String),
+    #[error("missing delimiter around `{0}`...")]
+    MissingDelimiter(String),
+    #[error("empty argument around `{0}`...")]
+    EmptyArgument(String),
+    #[error("invalid request argument (`{0}`)")]
+    InvalidRequestArg(String),
+    #[error("invalid response argument (`{0}`)")]
+    InvalidResponseArg(String),
+}
+
+#[derive(PartialEq, Debug)]
+pub enum Template {
+    Literal(String),
+    Placeholder(Token, Option<TokenArgument>), // eg. (Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
+}
+
+pub struct LogFormatter {
+    template: Vec<Template>,
+}
+
+impl LogFormatter {
+    pub fn try_new(typ: FormatType, input: &str) -> Result<LogFormatter, FormatError> {
+        match typ {
+            FormatType::Envoy => {
+                let template = EnvoyGrammar::parse(input)?;
+                Ok(LogFormatter { template })
+            },
+            FormatType::GridRouter => todo!(),
+        }
+    }
+
+    pub fn with_context<C: Context>(mut self, ctx: &C) -> Self {
+        for part in &mut self.template {
+            if let Template::Placeholder(token, arg) = part {
+                if let Some(value) = ctx.eval_part(token, arg) {
+                    *part = Template::Literal(value.into());
+                }
+            }
+        }
+
+        self
+    }
+}
+
+impl Display for LogFormatter {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        for part in &self.template {
+            match part {
+                Template::Literal(s) => f.write_str(s.as_ref())?,
+                Template::Placeholder(token, arg) => {
+                    f.write_str(&format!("%{}", token))?;
+                    if let Some(a) = arg {
+                        f.write_str("(")?;
+                        f.write_str(&format!("{}", a))?;
+                        f.write_str(")")?;
+                    }
+                    f.write_str(&format!("%"))?;
+                },
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum FormatType {
+    Envoy,
+    GridRouter,
+}
+
+pub trait Grammar {
+    fn parse(input: &str) -> Result<Vec<Template>, FormatError>;
+}
+
+pub trait Context {
+    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<Cow<'a, str>>;
+}
diff --git a/orion-format/src/token.rs b/orion-format/src/token.rs
new file mode 100644
index 00000000..6f629bcb
--- /dev/null
+++ b/orion-format/src/token.rs
@@ -0,0 +1,149 @@
+use http::HeaderName;
+use strum_macros::Display;
+
+#[derive(Display)]
+#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
+#[derive(Clone, Copy, PartialEq, Hash, Debug)]
+pub enum Token {
+    RequestDuration,
+    RequestTxDuration,
+    ResponseDuration,
+    ResponseTxDuration,
+    DownstreamHandshakeDuration,
+    RoundtripDuration,
+    BytesReceived,
+    BytesRetransmitted,
+    PacketsRetransmitted,
+    UpstreamWireBytesReceived,
+    UpstreamHeaderBytesReceived,
+    DownstreamWireBytesReceived,
+    DownstreamHeaderBytesReceived,
+    Protocol,
+    UpstreamProtocol,
+    ResponseCode,
+    ResponseCodeDetails,
+    ConnectionTerminationDetails,
+    BytesSent,
+    UpstreamWireBytesSent,
+    UpstreamHeaderBytesSent,
+    DownstreamWireBytesSent,
+    DownstreamHeaderBytesSent,
+    Duration,
+    CommonDuration,
+    CustomFlags,
+    ResponseFlags,
+    ResponseFlagsLong,
+    UpstreamHostName,
+    UpstreamHostNameWithoutPort,
+    UpstreamHost,
+    UpstreamConnectionId,
+    UpstreamCluster,
+    UpstreamClusterRaw,
+    UpstreamLocalAddress,
+    UpstreamLocalAddressWithoutPort,
+    UpstreamLocalPort,
+    UpstreamRemoteAddress,
+    UpstreamRemoteAddressWithoutPort,
+    UpstreamRemotePort,
+    UpstreamRequestAttemptCount,
+    UpstreamTlsCipher,
+    UpstreamTlsVersion,
+    UpstreamTlsSessionId,
+    UpstreamPeerIssuer,
+    UpstreamPeerCert,
+    UpstreamPeerSubject,
+    DownstreamLocalAddress,
+    DownstreamDirectLocalAddress,
+    DownstreamLocalAddressWithoutPort,
+    DownstreamDirectLocalAddressWithoutPort,
+    DownstreamLocalPort,
+    DownstreamDirectLocalPort,
+    DownstreamRemoteAddress,
+    DownstreamRemoteAddressWithoutPort,
+    DownstreamRemotePort,
+    DownstreamDirectRemoteAddress,
+    DownstreamDirectRemoteAddressWithoutPort,
+    DownstreamDirectRemotePort,
+    ConnectionId,
+    RequestedServerName,
+    RouteName,
+    UpstreamPeerUriSan,
+    UpstreamPeerDnsSan,
+    UpstreamPeerIpSan,
+    UpstreamLocalUriSan,
+    UpstreamLocalDnsSan,
+    UpstreamLocalIpSan,
+    DownstreamPeerUriSan,
+    DownstreamPeerDnsSan,
+    DownstreamPeerIpSan,
+    DownstreamPeerEmailSan,
+    DownstreamPeerOthernameSan,
+    DownstreamLocalUriSan,
+    DownstreamLocalDnsSan,
+    DownstreamLocalIpSan,
+    DownstreamLocalEmailSan,
+    DownstreamLocalOthernameSan,
+    DownstreamPeerSubject,
+    DownstreamLocalSubject,
+    DownstreamTlsSessionId,
+    DownstreamTlsCipher,
+    DownstreamTlsVersion,
+    DownstreamPeerFingerprint256,
+    DownstreamPeerFingerprint1,
+    DownstreamPeerSerial,
+    DownstreamPeerChainFingerprints256,
+    DownstreamPeerChainFingerprints1,
+    DownstreamPeerChainSerials,
+    DownstreamPeerIssuer,
+    DownstreamPeerCert,
+    DownstreamTransportFailureReason,
+    UpstreamTransportFailureReason,
+    Hostname,
+    FilterChainName,
+    VirtualClusterName,
+    TlsJa3Fingerprint,
+    UniqueId,
+    StreamId,
+    StartTime,
+    StartTimeLocal,
+    EmitTime,
+    EmitTimeLocal,
+    DynamicMetadata,
+    ClusterMetadata,
+    UpstreamMetadata,
+    FilterState,
+    UpstreamFilterState,
+    DownstreamPeerCertVStart,
+    DownstreamPeerCertVEnd,
+    UpstreamPeerCertVStart,
+    UpstreamPeerCertVEnd,
+    Environment,
+    UpstreamConnectionPoolReadyDuration,
+    Request,
+    Response,
+}
+
+#[derive(Display, Debug, Clone, PartialEq, Hash)]
+#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
+pub enum TokenArgument {
+    Request(ReqArg),
+    Response(RespArg),
+}
+
+#[derive(Display)]
+#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
+#[derive(Clone, PartialEq, Hash, Debug)]
+pub enum ReqArg {
+    Scheme,
+    Method,
+    Path,
+    Authority,
+    Header(HeaderName),
+}
+
+#[derive(Display)]
+#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
+#[derive(Clone, PartialEq, Hash, Debug)]
+pub enum RespArg {
+    Header(HeaderName),
+}

From afd6ecd23e78f4934f2d566cf029450796c23268 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 12 May 2025 16:44:50 +0200
Subject: [PATCH 09/64] Add benchmarking and context evaluation for request
 formatting

- Introduced Criterion-based benchmarks for request formatting.
- Added `Context` trait implementations for `Request` and `Response`.
- Updated `EnvoyGrammar` to handle placeholders with original strings.
- Refactored `Template` to include original placeholder strings.
- Added tests for request context evaluation and default format string.
- Removed `strum` dependency for token display.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml           | 10 +++-
 orion-format/benches/benchmark.rs | 48 +++++++++++++++
 orion-format/src/context.rs       | 40 +++++++++++++
 orion-format/src/envoy.rs         | 61 ++++++++++++++-----
 orion-format/src/lib.rs           | 99 ++++++++++++++++++++++++++-----
 orion-format/src/token.rs         | 14 +----
 6 files changed, 227 insertions(+), 45 deletions(-)
 create mode 100644 orion-format/benches/benchmark.rs

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index d080840a..2319a1d8 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -8,8 +8,12 @@ workspace = true
 
 [dependencies]
 http.workspace = true
+thiserror.workspace = true
+
+criterion = "0.5.1"
 lazy_static = "1.5.0"
 ptrie = "0.7.2"
-strum = { version = "0.27.1", features = ["derive"] }
-strum_macros = "0.27.1"
-thiserror.workspace = true
+
+[[bench]]
+name = "benchmark"
+harness = false
diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
new file mode 100644
index 00000000..4f612ed0
--- /dev/null
+++ b/orion-format/benches/benchmark.rs
@@ -0,0 +1,48 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use http::Request;
+use orion_format::{FormatType, LogFormatter};
+
+fn eval_format(req: &Request<()>, mut fmt: LogFormatter) {
+    fmt.with_context(req);
+}
+
+fn benchmark_with_request_context(c: &mut Criterion) {
+    let request = Request::builder()
+        .uri("https://www.rust-lang.org/hello")
+        .header("User-Agent", "my-awesome-agent/1.0")
+        .body(())
+        .unwrap();
+
+    let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(:PATH)%").unwrap();
+    c.bench_function("req(:path)", |b| b.iter(|| black_box(eval_format(black_box(&request), fmt.clone()))));
+
+    let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(:METHOD)%").unwrap();
+    c.bench_function("req(:method)", |b| b.iter(|| black_box(eval_format(black_box(&request), fmt.clone()))));
+
+    let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(USER-AGENT)%").unwrap();
+    c.bench_function("req(:user-agent)", |b| b.iter(|| black_box(eval_format(black_box(&request), fmt.clone()))));
+}
+
+fn benchmark_default_format(c: &mut Criterion) {
+    let request = Request::builder()
+        .uri("https://www.rust-lang.org/hello")
+        .header("User-Agent", "my-awesome-agent/1.0")
+        .body(())
+        .unwrap();
+
+    let fmt = LogFormatter::try_new(
+        FormatType::Envoy,
+        r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%"
+    %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION%
+    %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%"
+    "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#,
+    )
+    .unwrap();
+
+    c.bench_function("Envoy default formatter", |b| {
+        b.iter(|| black_box(eval_format(black_box(&request), fmt.clone())))
+    });
+}
+
+criterion_group!(benches, benchmark_with_request_context, benchmark_default_format);
+criterion_main!(benches);
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index e69de29b..1942b56e 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -0,0 +1,40 @@
+use http::{Request, Response};
+use std::borrow::Cow;
+
+use crate::token::{ReqArg, RespArg, Token, TokenArgument};
+
+pub trait Context {
+    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<Cow<'a, str>>;
+}
+
+impl<T> Context for Request<T> {
+    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<Cow<'a, str>> {
+        match (token, arg) {
+            (Token::Request, Some(TokenArgument::Request(ReqArg::Path))) => Some(Cow::Borrowed(self.uri().path())),
+            (Token::Request, Some(TokenArgument::Request(ReqArg::Authority))) => {
+                self.uri().authority().and_then(|a| Some(Cow::Borrowed(a.host())))
+            },
+            (Token::Request, Some(TokenArgument::Request(ReqArg::Method))) => {
+                Some(Cow::Borrowed(self.method().as_str()))
+            },
+            (Token::Request, Some(TokenArgument::Request(ReqArg::Scheme))) => {
+                self.uri().scheme().map(|s| Cow::Owned(format!("{}", s)))
+            },
+            (Token::Request, Some(TokenArgument::Request(ReqArg::NormalHeader(h)))) => {
+                self.headers().get(h).and_then(|v| v.to_str().ok().map(Cow::Borrowed))
+            },
+            _ => None,
+        }
+    }
+}
+
+impl<T> Context for Response<T> {
+    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<Cow<'a, str>> {
+        match (token, arg) {
+            (Token::Request, Some(TokenArgument::Response(RespArg::NormalHeader(h)))) => {
+                self.headers().get(h).and_then(|v| v.to_str().ok().map(Cow::Borrowed))
+            },
+            _ => None,
+        }
+    }
+}
diff --git a/orion-format/src/envoy.rs b/orion-format/src/envoy.rs
index a6ab1e27..14295f2b 100644
--- a/orion-format/src/envoy.rs
+++ b/orion-format/src/envoy.rs
@@ -159,7 +159,7 @@ impl EnvoyGrammar {
             None => {
                 let name =
                     HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidRequestArg(arg.into()))?;
-                Ok(ReqArg::Header(name))
+                Ok(ReqArg::NormalHeader(name))
             },
         }
     }
@@ -170,7 +170,7 @@ impl EnvoyGrammar {
             None => {
                 let name =
                     HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidResponseArg(arg.into()))?;
-                Ok(RespArg::Header(name))
+                Ok(RespArg::NormalHeader(name))
             },
         }
     }
@@ -231,19 +231,19 @@ impl Grammar for EnvoyGrammar {
                         }
 
                         if !after_placeholder[arg_len..].starts_with("%") {
-                            return Err(FormatError::MissingDelimiter(input[i + *placeholder_len..].into()));
+                            return Err(FormatError::MissingDelimiter(remainder.into()));
                         }
 
                         skip = Some(2 + *placeholder_len + arg_len);
                     } else {
                         longest_placeholder = Some((*placeholder, *placeholder_len, None));
                         if !after_placeholder.starts_with("%") {
-                            return Err(FormatError::MissingDelimiter(input[i + *placeholder_len..].into()));
+                            return Err(FormatError::MissingDelimiter(remainder.into()));
                         }
                         skip = Some(2 + *placeholder_len);
                     }
                 } else {
-                    return Err(FormatError::UnsupportedPattern(input[i..].into()));
+                    return Err(FormatError::UnsupportedPattern(remainder.into()));
                 }
             }
 
@@ -255,7 +255,11 @@ impl Grammar for EnvoyGrammar {
                 }
 
                 // Add this placeholder.
-                parts.push(Template::Placeholder(placeholder.0.into(), placeholder.2.clone()));
+                parts.push(Template::Placeholder(
+                    input[i..i + skip.unwrap()].into(),
+                    placeholder.0.into(),
+                    placeholder.2.clone(),
+                ));
 
                 // advnace the index beyond the current placeholder and possibly its argument.
                 i += skip.unwrap();
@@ -294,8 +298,10 @@ mod tests {
     #[test]
     fn test_parse_only_placeholders() {
         let input = "%START_TIME%%PROTOCOL%";
-        let expected =
-            vec![Template::Placeholder(Token::StartTime, None), Template::Placeholder(Token::Protocol, None)];
+        let expected = vec![
+            Template::Placeholder("%START_TIME%".into(), Token::StartTime, None),
+            Template::Placeholder("%PROTOCOL%".into(), Token::Protocol, None),
+        ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
@@ -305,9 +311,13 @@ mod tests {
         let input = "Start %REQ(:METHOD)% middle %PROTOCOL% end.";
         let expected = vec![
             Template::Literal("Start ".into()),
-            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Method))),
+            Template::Placeholder(
+                "%REQ(:METHOD)%".into(),
+                Token::Request,
+                Some(TokenArgument::Request(ReqArg::Method)),
+            ),
             Template::Literal(" middle ".into()),
-            Template::Placeholder(Token::Protocol, None),
+            Template::Placeholder("%PROTOCOL%".into(), Token::Protocol, None),
             Template::Literal(" end.".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
@@ -317,7 +327,10 @@ mod tests {
     #[test]
     fn test_parse_starts_with_placeholder() {
         let input = "%START_TIME% literal after.";
-        let expected = vec![Template::Placeholder(Token::StartTime, None), Template::Literal(" literal after.".into())];
+        let expected = vec![
+            Template::Placeholder("%START_TIME%".into(), Token::StartTime, None),
+            Template::Literal(" literal after.".into()),
+        ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
@@ -325,7 +338,10 @@ mod tests {
     #[test]
     fn test_parse_ends_with_placeholder() {
         let input = "Literal before %PROTOCOL%";
-        let expected = vec![Template::Literal("Literal before ".into()), Template::Placeholder(Token::Protocol, None)];
+        let expected = vec![
+            Template::Literal("Literal before ".into()),
+            Template::Placeholder("%PROTOCOL%".into(), Token::Protocol, None),
+        ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
@@ -351,19 +367,32 @@ mod tests {
         let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%""#;
         let expected = vec![
             Template::Literal("[".into()),
-            Template::Placeholder(Token::StartTime, None),
+            Template::Placeholder("%START_TIME%".into(), Token::StartTime, None),
             Template::Literal("] \"".into()),
-            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Method))),
+            Template::Placeholder(
+                "%REQ(:METHOD)%".into(),
+                Token::Request,
+                Some(TokenArgument::Request(ReqArg::Method)),
+            ),
             Template::Literal(" ".into()),
-            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Path))),
+            Template::Placeholder("%REQ(:PATH)%".into(), Token::Request, Some(TokenArgument::Request(ReqArg::Path))),
             Template::Literal(" ".into()),
-            Template::Placeholder(Token::Protocol, None),
+            Template::Placeholder("%PROTOCOL%".into(), Token::Protocol, None),
             Template::Literal("\"".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
 
+    #[test]
+    fn test_default_fmt() {
+        let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%"
+            %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION%
+            %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%"
+            "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+        let result = EnvoyGrammar::parse(input).unwrap();
+    }
+
     // bad patters..
 
     #[test]
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 8c8eaf04..1d97e27a 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -2,7 +2,7 @@ pub mod context;
 pub mod envoy;
 pub mod token;
 
-use std::borrow::Cow;
+use context::Context;
 use std::fmt::{self, Display, Formatter};
 use thiserror::Error;
 use token::{Token, TokenArgument};
@@ -27,12 +27,13 @@ pub enum FormatError {
     InvalidResponseArg(String),
 }
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Debug, Clone)]
 pub enum Template {
     Literal(String),
-    Placeholder(Token, Option<TokenArgument>), // eg. (Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
+    Placeholder(String, Token, Option<TokenArgument>), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
 }
 
+#[derive(Debug, Clone)]
 pub struct LogFormatter {
     template: Vec<Template>,
 }
@@ -48,9 +49,9 @@ impl LogFormatter {
         }
     }
 
-    pub fn with_context<C: Context>(mut self, ctx: &C) -> Self {
+    pub fn with_context<C: Context>(&mut self, ctx: &C) -> &mut Self {
         for part in &mut self.template {
-            if let Template::Placeholder(token, arg) = part {
+            if let Template::Placeholder(_, token, arg) = part {
                 if let Some(value) = ctx.eval_part(token, arg) {
                     *part = Template::Literal(value.into());
                 }
@@ -66,14 +67,8 @@ impl Display for LogFormatter {
         for part in &self.template {
             match part {
                 Template::Literal(s) => f.write_str(s.as_ref())?,
-                Template::Placeholder(token, arg) => {
-                    f.write_str(&format!("%{}", token))?;
-                    if let Some(a) = arg {
-                        f.write_str("(")?;
-                        f.write_str(&format!("{}", a))?;
-                        f.write_str(")")?;
-                    }
-                    f.write_str(&format!("%"))?;
+                Template::Placeholder(orig, _, _) => {
+                    f.write_str(&format!("{}", orig))?;
                 },
             }
         }
@@ -91,6 +86,80 @@ pub trait Grammar {
     fn parse(input: &str) -> Result<Vec<Template>, FormatError>;
 }
 
-pub trait Context {
-    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<Cow<'a, str>>;
+#[cfg(test)]
+mod tests {
+    use http::Request;
+
+    use super::*;
+
+    fn build_request() -> Request<()> {
+        Request::builder()
+            .uri("https://www.rust-lang.org/")
+            .header("User-Agent", "my-awesome-agent/1.0")
+            .body(())
+            .unwrap()
+    }
+
+    #[test]
+    fn test_request_path() {
+        let req = build_request();
+        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:PATH)%").unwrap();
+        let expected = "/";
+        formatter.with_context(&req);
+        let actual = format!("{}", &formatter);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_request_method() {
+        let req = build_request();
+        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:METHOD)%").unwrap();
+        let expected = "GET";
+        formatter.with_context(&req);
+        let actual = format!("{}", &formatter);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_request_scheme() {
+        let req = build_request();
+        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:SCHEME)%").unwrap();
+        let expected = "https";
+        formatter.with_context(&req);
+        let actual = format!("{}", &formatter);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_request_authority() {
+        let req = build_request();
+        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:AUTHORITY)%").unwrap();
+        let expected = "www.rust-lang.org";
+        formatter.with_context(&req);
+        let actual = format!("{}", &formatter);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_request_user_agent() {
+        let req = build_request();
+        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(USER-AGENT)%").unwrap();
+        let expected = "my-awesome-agent/1.0";
+        formatter.with_context(&req);
+        let actual = format!("{}", &formatter);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn default_format_string() {
+        let req = build_request();
+        let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%"
+            %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION%
+            %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%"
+            "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+        let mut formatter = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
+        formatter.with_context(&req);
+        let actual = format!("{}", &formatter);
+        println!("{}", actual);
+    }
 }
diff --git a/orion-format/src/token.rs b/orion-format/src/token.rs
index 6f629bcb..7133cd29 100644
--- a/orion-format/src/token.rs
+++ b/orion-format/src/token.rs
@@ -1,8 +1,5 @@
 use http::HeaderName;
-use strum_macros::Display;
 
-#[derive(Display)]
-#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
 #[derive(Clone, Copy, PartialEq, Hash, Debug)]
 pub enum Token {
     RequestDuration,
@@ -123,27 +120,22 @@ pub enum Token {
     Response,
 }
 
-#[derive(Display, Debug, Clone, PartialEq, Hash)]
-#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
+#[derive(Debug, Clone, PartialEq, Hash)]
 pub enum TokenArgument {
     Request(ReqArg),
     Response(RespArg),
 }
 
-#[derive(Display)]
-#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
 #[derive(Clone, PartialEq, Hash, Debug)]
 pub enum ReqArg {
     Scheme,
     Method,
     Path,
     Authority,
-    Header(HeaderName),
+    NormalHeader(HeaderName),
 }
 
-#[derive(Display)]
-#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
 #[derive(Clone, PartialEq, Hash, Debug)]
 pub enum RespArg {
-    Header(HeaderName),
+    NormalHeader(HeaderName),
 }

From 1ee7f1ef84eac12d1a1c32cc1da043a91635883b Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 12 May 2025 18:09:37 +0200
Subject: [PATCH 10/64] Add response context support to log formatter

- Updated `LogFormatter` to include response context.
- Added `%RESPONSE_CODE%` and response headers to supported tokens.
- Modified benchmarks to include response context.
- Updated tests to validate response context functionality.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 33 ++++++++++++++++++-------------
 orion-format/src/context.rs       | 28 ++++++++++++++++++++++----
 orion-format/src/envoy.rs         |  2 +-
 orion-format/src/lib.rs           | 22 ++++++++++-----------
 4 files changed, 55 insertions(+), 30 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 4f612ed0..1c0be973 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -1,9 +1,10 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use http::Request;
+use http::{Request, Response, StatusCode};
 use orion_format::{FormatType, LogFormatter};
 
-fn eval_format(req: &Request<()>, mut fmt: LogFormatter) {
+fn eval_format(req: &Request<()>, resp: &Response<()>, mut fmt: LogFormatter) {
     fmt.with_context(req);
+    fmt.with_context(resp);
 }
 
 fn benchmark_with_request_context(c: &mut Criterion) {
@@ -13,14 +14,22 @@ fn benchmark_with_request_context(c: &mut Criterion) {
         .body(())
         .unwrap();
 
+    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+
     let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(:PATH)%").unwrap();
-    c.bench_function("req(:path)", |b| b.iter(|| black_box(eval_format(black_box(&request), fmt.clone()))));
+    c.bench_function("REQ(:PATH)", |b| {
+        b.iter(|| black_box(eval_format(black_box(&request), black_box(&response), fmt.clone())))
+    });
 
     let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(:METHOD)%").unwrap();
-    c.bench_function("req(:method)", |b| b.iter(|| black_box(eval_format(black_box(&request), fmt.clone()))));
+    c.bench_function("REQ(:METHOD)", |b| {
+        b.iter(|| black_box(eval_format(black_box(&request), black_box(&response), fmt.clone())))
+    });
 
     let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(USER-AGENT)%").unwrap();
-    c.bench_function("req(:user-agent)", |b| b.iter(|| black_box(eval_format(black_box(&request), fmt.clone()))));
+    c.bench_function("REQ(USER-AGENT)", |b| {
+        b.iter(|| black_box(eval_format(black_box(&request), black_box(&response), fmt.clone())))
+    });
 }
 
 fn benchmark_default_format(c: &mut Criterion) {
@@ -30,17 +39,13 @@ fn benchmark_default_format(c: &mut Criterion) {
         .body(())
         .unwrap();
 
-    let fmt = LogFormatter::try_new(
-        FormatType::Envoy,
-        r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%"
-    %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION%
-    %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%"
-    "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#,
-    )
-    .unwrap();
+    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+
+    let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+    let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
 
     c.bench_function("Envoy default formatter", |b| {
-        b.iter(|| black_box(eval_format(black_box(&request), fmt.clone())))
+        b.iter(|| black_box(eval_format(black_box(&request), black_box(&response), fmt.clone())))
     });
 }
 
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 1942b56e..ca253035 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -1,4 +1,4 @@
-use http::{Request, Response};
+use http::{Request, Response, Version};
 use std::borrow::Cow;
 
 use crate::token::{ReqArg, RespArg, Token, TokenArgument};
@@ -21,7 +21,22 @@ impl<T> Context for Request<T> {
                 self.uri().scheme().map(|s| Cow::Owned(format!("{}", s)))
             },
             (Token::Request, Some(TokenArgument::Request(ReqArg::NormalHeader(h)))) => {
-                self.headers().get(h).and_then(|v| v.to_str().ok().map(Cow::Borrowed))
+                let hv = self.headers().get(h);
+                match hv {
+                    Some(hv) => hv.to_str().ok().map(Cow::Borrowed),
+                    None => Some(Cow::Borrowed("")),
+                }
+            },
+            (Token::Protocol, _) => {
+                let ver = match self.version() {
+                    Version::HTTP_10 => "HTTP/1.0",
+                    Version::HTTP_11 => "HTTP/1.1",
+                    Version::HTTP_2 => "HTTP/2",
+                    Version::HTTP_3 => "HTTP/3",
+                    _ => "HTTP/UNKNOWN",
+                };
+
+                Some(Cow::Borrowed(ver))
             },
             _ => None,
         }
@@ -31,8 +46,13 @@ impl<T> Context for Request<T> {
 impl<T> Context for Response<T> {
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<Cow<'a, str>> {
         match (token, arg) {
-            (Token::Request, Some(TokenArgument::Response(RespArg::NormalHeader(h)))) => {
-                self.headers().get(h).and_then(|v| v.to_str().ok().map(Cow::Borrowed))
+            (Token::ResponseCode, _) => Some(Cow::Owned(self.status().as_str().to_owned())),
+            (Token::Response, Some(TokenArgument::Response(RespArg::NormalHeader(h)))) => {
+                let hv = self.headers().get(h);
+                match hv {
+                    Some(hv) => hv.to_str().ok().map(Cow::Borrowed),
+                    None => Some(Cow::Borrowed("")),
+                }
             },
             _ => None,
         }
diff --git a/orion-format/src/envoy.rs b/orion-format/src/envoy.rs
index 14295f2b..bc6634db 100644
--- a/orion-format/src/envoy.rs
+++ b/orion-format/src/envoy.rs
@@ -390,7 +390,7 @@ mod tests {
             %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION%
             %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%"
             "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
-        let result = EnvoyGrammar::parse(input).unwrap();
+        _ = EnvoyGrammar::parse(input).unwrap();
     }
 
     // bad patters..
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 1d97e27a..e425f47d 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -88,16 +88,17 @@ pub trait Grammar {
 
 #[cfg(test)]
 mod tests {
-    use http::Request;
+    use http::{Request, Response, StatusCode};
 
     use super::*;
 
     fn build_request() -> Request<()> {
-        Request::builder()
-            .uri("https://www.rust-lang.org/")
-            .header("User-Agent", "my-awesome-agent/1.0")
-            .body(())
-            .unwrap()
+        Request::builder().uri("https://www.rust-lang.org/").header("User-Agent", "awesome/1.0").body(()).unwrap()
+    }
+
+    fn build_response() -> Response<()> {
+        let builder = Response::builder().status(StatusCode::OK);
+        builder.body(()).unwrap()
     }
 
     #[test]
@@ -144,7 +145,7 @@ mod tests {
     fn test_request_user_agent() {
         let req = build_request();
         let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(USER-AGENT)%").unwrap();
-        let expected = "my-awesome-agent/1.0";
+        let expected = "awesome/1.0";
         formatter.with_context(&req);
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
@@ -153,12 +154,11 @@ mod tests {
     #[test]
     fn default_format_string() {
         let req = build_request();
-        let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%"
-            %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION%
-            %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%"
-            "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+        let resp = build_response();
+        let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
         let mut formatter = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
         formatter.with_context(&req);
+        formatter.with_context(&resp);
         let actual = format!("{}", &formatter);
         println!("{}", actual);
     }

From eefdf49a9539f61e1293c9aac4c27332ffc7231c Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 12 May 2025 19:09:50 +0200
Subject: [PATCH 11/64] Add `smol_str` dependency and refactor to use `SmolStr`

- Updated `Template::Literal` and `Template::Placeholder` to use
`SmolStr`.
- Replaced `String` with `SmolStr` in relevant parts of the code.
- Adjusted `LogFormatter` and `Context` implementations accordingly.
- Added a new benchmark for cloning `LogFormatter`.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml           |  1 +
 orion-format/benches/benchmark.rs | 10 ++++++++--
 orion-format/src/context.rs       |  2 +-
 orion-format/src/envoy.rs         |  4 ++--
 orion-format/src/lib.rs           | 11 ++++++-----
 5 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index 2319a1d8..82d07ae4 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -13,6 +13,7 @@ thiserror.workspace = true
 criterion = "0.5.1"
 lazy_static = "1.5.0"
 ptrie = "0.7.2"
+smol_str = "0.3.2"
 
 [[bench]]
 name = "benchmark"
diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 1c0be973..000bd2a5 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -7,7 +7,7 @@ fn eval_format(req: &Request<()>, resp: &Response<()>, mut fmt: LogFormatter) {
     fmt.with_context(resp);
 }
 
-fn benchmark_with_request_context(c: &mut Criterion) {
+fn benchmark_request(c: &mut Criterion) {
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")
         .header("User-Agent", "my-awesome-agent/1.0")
@@ -49,5 +49,11 @@ fn benchmark_default_format(c: &mut Criterion) {
     });
 }
 
-criterion_group!(benches, benchmark_with_request_context, benchmark_default_format);
+fn benchmark_clone_formatter(c: &mut Criterion) {
+    let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+    let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
+    c.bench_function("Clone formatter", |b| b.iter(|| black_box(black_box(fmt.clone()))));
+}
+
+criterion_group!(benches, benchmark_default_format, benchmark_clone_formatter, benchmark_request);
 criterion_main!(benches);
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index ca253035..efd87a81 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -48,7 +48,7 @@ impl<T> Context for Response<T> {
         match (token, arg) {
             (Token::ResponseCode, _) => Some(Cow::Owned(self.status().as_str().to_owned())),
             (Token::Response, Some(TokenArgument::Response(RespArg::NormalHeader(h)))) => {
-                let hv = self.headers().get(h);
+                let hv = self.headers().get(h.as_str());
                 match hv {
                     Some(hv) => hv.to_str().ok().map(Cow::Borrowed),
                     None => Some(Cow::Borrowed("")),
diff --git a/orion-format/src/envoy.rs b/orion-format/src/envoy.rs
index bc6634db..6bd5eeb8 100644
--- a/orion-format/src/envoy.rs
+++ b/orion-format/src/envoy.rs
@@ -251,7 +251,7 @@ impl Grammar for EnvoyGrammar {
                 // placeholder found
                 if i > literal_start {
                     let literal_text = &input[literal_start..i];
-                    parts.push(Template::Literal(literal_text.to_string()));
+                    parts.push(Template::Literal(literal_text.into()));
                 }
 
                 // Add this placeholder.
@@ -275,7 +275,7 @@ impl Grammar for EnvoyGrammar {
         if i > literal_start {
             let literal_text = &input[literal_start..i];
 
-            parts.push(Template::Literal(literal_text.replace("%%", "%")));
+            parts.push(Template::Literal(literal_text.replace("%%", "%").into()));
         }
 
         Ok(parts)
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index e425f47d..bc2849df 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -3,6 +3,7 @@ pub mod envoy;
 pub mod token;
 
 use context::Context;
+use smol_str::SmolStr;
 use std::fmt::{self, Display, Formatter};
 use thiserror::Error;
 use token::{Token, TokenArgument};
@@ -29,11 +30,11 @@ pub enum FormatError {
 
 #[derive(PartialEq, Debug, Clone)]
 pub enum Template {
-    Literal(String),
-    Placeholder(String, Token, Option<TokenArgument>), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
+    Literal(SmolStr),
+    Placeholder(SmolStr, Token, Option<TokenArgument>), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
 }
 
-#[derive(Debug, Clone)]
+#[derive(PartialEq, Debug, Clone)]
 pub struct LogFormatter {
     template: Vec<Template>,
 }
@@ -49,11 +50,11 @@ impl LogFormatter {
         }
     }
 
-    pub fn with_context<C: Context>(&mut self, ctx: &C) -> &mut Self {
+    pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
         for part in &mut self.template {
             if let Template::Placeholder(_, token, arg) = part {
                 if let Some(value) = ctx.eval_part(token, arg) {
-                    *part = Template::Literal(value.into());
+                    *part = Template::Literal(value.into()); // TODO: Reduce memory allocations by grouping consecutive templates
                 }
             }
         }

From 99ff0a5acb187271686c70b04cceac59096795f7 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 13 May 2025 06:37:27 +0200
Subject: [PATCH 12/64] Replace Cow with SmolCow for optimized string handling

Introduce SmolCow enum to reduce memory allocations and improve
performance (~30% on average). Update Context trait and related implementations to
use SmolCow instead of Cow. Add smol_cow module to define SmolCow
and its associated methods.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs |  30 ++++++++-
 orion-format/src/context.rs       |  29 +++++----
 orion-format/src/lib.rs           |   3 +-
 orion-format/src/smol_cow.rs      | 102 ++++++++++++++++++++++++++++++
 4 files changed, 146 insertions(+), 18 deletions(-)
 create mode 100644 orion-format/src/smol_cow.rs

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 000bd2a5..07e1c8c5 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -1,6 +1,7 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use http::{Request, Response, StatusCode};
-use orion_format::{FormatType, LogFormatter};
+use orion_format::{smol_cow::SmolCow, FormatType, LogFormatter};
+use smol_str::SmolStr;
 
 fn eval_format(req: &Request<()>, resp: &Response<()>, mut fmt: LogFormatter) {
     fmt.with_context(req);
@@ -52,8 +53,31 @@ fn benchmark_default_format(c: &mut Criterion) {
 fn benchmark_clone_formatter(c: &mut Criterion) {
     let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
     let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
-    c.bench_function("Clone formatter", |b| b.iter(|| black_box(black_box(fmt.clone()))));
+    c.bench_function("Clone formatter", |b| b.iter(|| black_box(fmt.clone())));
 }
 
-criterion_group!(benches, benchmark_default_format, benchmark_clone_formatter, benchmark_request);
+fn ret_small_cow() -> SmolCow<'static> {
+    SmolCow::Borrowed("123456789012345678901234567890")
+}
+
+fn ret_small_str() -> SmolStr {
+    SmolStr::new("123456789012345678901234567890")
+}
+
+fn benchmark_small_cow(c: &mut Criterion) {
+    c.bench_function("small_cow", |b| {
+        b.iter(|| {
+            let s = black_box(ret_small_cow());
+            black_box(s.into_owned());
+        })
+    });
+    c.bench_function("small_str", |b| {
+        b.iter(|| {
+            let s = black_box(ret_small_str());
+            black_box(s.clone());
+        })
+    });
+}
+
+criterion_group!(benches, benchmark_default_format, benchmark_clone_formatter, benchmark_request, benchmark_small_cow);
 criterion_main!(benches);
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index efd87a81..007e5820 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -1,30 +1,31 @@
 use http::{Request, Response, Version};
-use std::borrow::Cow;
+use smol_str::{format_smolstr, SmolStr};
 
+use crate::smol_cow::SmolCow;
 use crate::token::{ReqArg, RespArg, Token, TokenArgument};
 
 pub trait Context {
-    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<Cow<'a, str>>;
+    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>>;
 }
 
 impl<T> Context for Request<T> {
-    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<Cow<'a, str>> {
+    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match (token, arg) {
-            (Token::Request, Some(TokenArgument::Request(ReqArg::Path))) => Some(Cow::Borrowed(self.uri().path())),
+            (Token::Request, Some(TokenArgument::Request(ReqArg::Path))) => Some(SmolCow::Borrowed(self.uri().path())),
             (Token::Request, Some(TokenArgument::Request(ReqArg::Authority))) => {
-                self.uri().authority().and_then(|a| Some(Cow::Borrowed(a.host())))
+                self.uri().authority().and_then(|a| Some(SmolCow::Borrowed(a.host())))
             },
             (Token::Request, Some(TokenArgument::Request(ReqArg::Method))) => {
-                Some(Cow::Borrowed(self.method().as_str()))
+                Some(SmolCow::Borrowed(self.method().as_str()))
             },
             (Token::Request, Some(TokenArgument::Request(ReqArg::Scheme))) => {
-                self.uri().scheme().map(|s| Cow::Owned(format!("{}", s)))
+                self.uri().scheme().map(|s| SmolCow::Owned(format_smolstr!("{}", s)))
             },
             (Token::Request, Some(TokenArgument::Request(ReqArg::NormalHeader(h)))) => {
                 let hv = self.headers().get(h);
                 match hv {
-                    Some(hv) => hv.to_str().ok().map(Cow::Borrowed),
-                    None => Some(Cow::Borrowed("")),
+                    Some(hv) => hv.to_str().ok().map(SmolCow::Borrowed),
+                    None => Some(SmolCow::Borrowed("")),
                 }
             },
             (Token::Protocol, _) => {
@@ -36,7 +37,7 @@ impl<T> Context for Request<T> {
                     _ => "HTTP/UNKNOWN",
                 };
 
-                Some(Cow::Borrowed(ver))
+                Some(SmolCow::Borrowed(ver))
             },
             _ => None,
         }
@@ -44,14 +45,14 @@ impl<T> Context for Request<T> {
 }
 
 impl<T> Context for Response<T> {
-    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<Cow<'a, str>> {
+    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match (token, arg) {
-            (Token::ResponseCode, _) => Some(Cow::Owned(self.status().as_str().to_owned())),
+            (Token::ResponseCode, _) => Some(SmolCow::Owned(SmolStr::new_inline(self.status().as_str()))),
             (Token::Response, Some(TokenArgument::Response(RespArg::NormalHeader(h)))) => {
                 let hv = self.headers().get(h.as_str());
                 match hv {
-                    Some(hv) => hv.to_str().ok().map(Cow::Borrowed),
-                    None => Some(Cow::Borrowed("")),
+                    Some(hv) => hv.to_str().ok().map(SmolCow::Borrowed),
+                    None => Some(SmolCow::Borrowed("")),
                 }
             },
             _ => None,
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index bc2849df..6edf8344 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod context;
 pub mod envoy;
+pub mod smol_cow;
 pub mod token;
 
 use context::Context;
@@ -54,7 +55,7 @@ impl LogFormatter {
         for part in &mut self.template {
             if let Template::Placeholder(_, token, arg) = part {
                 if let Some(value) = ctx.eval_part(token, arg) {
-                    *part = Template::Literal(value.into()); // TODO: Reduce memory allocations by grouping consecutive templates
+                    *part = Template::Literal(value.into_owned()); // TODO: Reduce memory allocations by grouping consecutive expanded templates
                 }
             }
         }
diff --git a/orion-format/src/smol_cow.rs b/orion-format/src/smol_cow.rs
new file mode 100644
index 00000000..6e80a6cc
--- /dev/null
+++ b/orion-format/src/smol_cow.rs
@@ -0,0 +1,102 @@
+use core::fmt;
+use smol_str::SmolStr;
+use std::borrow::Borrow;
+use std::ops::Deref;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SmolCow<'a> {
+    Borrowed(&'a str),
+    Owned(SmolStr),
+}
+
+impl<'a> SmolCow<'a> {
+    #[inline]
+    pub fn into_owned(self) -> SmolStr {
+        match self {
+            SmolCow::Borrowed(s) => SmolStr::new(s),
+            SmolCow::Owned(s) => s,
+        }
+    }
+
+    #[inline]
+    pub const fn is_borrowed(&self) -> bool {
+        match *self {
+            SmolCow::Borrowed(_) => true,
+            SmolCow::Owned(_) => false,
+        }
+    }
+
+    #[inline]
+    pub const fn is_owned(&self) -> bool {
+        !self.is_borrowed()
+    }
+
+    pub fn to_mut(&mut self) -> &mut SmolStr {
+        match *self {
+            SmolCow::Borrowed(borrowed) => {
+                *self = SmolCow::Owned(SmolStr::new(borrowed));
+                match *self {
+                    SmolCow::Borrowed(..) => unreachable!(),
+                    SmolCow::Owned(ref mut owned) => owned,
+                }
+            },
+            SmolCow::Owned(ref mut owned) => owned,
+        }
+    }
+}
+
+impl fmt::Display for SmolCow<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            SmolCow::Borrowed(ref b) => fmt::Display::fmt(b, f),
+            SmolCow::Owned(ref o) => fmt::Display::fmt(o, f),
+        }
+    }
+}
+
+impl<'a> Deref for SmolCow<'a> {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            SmolCow::Borrowed(s) => s,
+            SmolCow::Owned(s) => s.deref(),
+        }
+    }
+}
+
+impl<'a> AsRef<str> for SmolCow<'a> {
+    fn as_ref(&self) -> &str {
+        self.deref()
+    }
+}
+
+impl<'a> Borrow<str> for SmolCow<'a> {
+    fn borrow(&self) -> &str {
+        self.deref()
+    }
+}
+
+impl<'a> From<&'a str> for SmolCow<'a> {
+    fn from(s: &'a str) -> Self {
+        SmolCow::Borrowed(s)
+    }
+}
+
+impl<'a> From<&'a String> for SmolCow<'a> {
+    fn from(s: &'a String) -> Self {
+        SmolCow::Owned(SmolStr::new(s))
+    }
+}
+
+impl From<SmolStr> for SmolCow<'static> {
+    fn from(s: SmolStr) -> Self {
+        SmolCow::Owned(s)
+    }
+}
+
+impl From<String> for SmolCow<'static> {
+    fn from(s: String) -> Self {
+        SmolCow::Owned(s.into())
+    }
+}

From e7e37d70903ae6b99040e384fd2854c1ec0896fc Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 13 May 2025 09:14:12 +0200
Subject: [PATCH 13/64] Add support for start and end context in log formatting

- Introduced `StartContext` and `EndContext` for capturing start time,
  duration, bytes received, and bytes sent.
- Updated benchmarks and tests to include the new context types.
- Added `chrono` dependency for timestamp formatting.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml           |  1 +
 orion-format/benches/benchmark.rs | 62 +++++++++++++++++++++++++++---
 orion-format/src/context.rs       | 64 ++++++++++++++++++++++++++-----
 orion-format/src/lib.rs           | 24 ++++++++----
 4 files changed, 128 insertions(+), 23 deletions(-)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index 82d07ae4..ac1ace93 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -14,6 +14,7 @@ criterion = "0.5.1"
 lazy_static = "1.5.0"
 ptrie = "0.7.2"
 smol_str = "0.3.2"
+chrono = "0.4.40"
 
 [[bench]]
 name = "benchmark"
diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 07e1c8c5..4f7cdcf5 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -1,11 +1,25 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use http::{Request, Response, StatusCode};
-use orion_format::{smol_cow::SmolCow, FormatType, LogFormatter};
+use orion_format::{
+    context::{Context, DownStreamRequest, DownStreamResponse, EndContext, StartContext},
+    smol_cow::SmolCow,
+    FormatType, LogFormatter,
+};
 use smol_str::SmolStr;
+use std::time::Duration;
 
-fn eval_format(req: &Request<()>, resp: &Response<()>, mut fmt: LogFormatter) {
+#[inline]
+fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, mut fmt: LogFormatter)
+where
+    C1: Context,
+    C2: Context,
+    C3: Context,
+    C4: Context,
+{
     fmt.with_context(req);
     fmt.with_context(resp);
+    fmt.with_context(start);
+    fmt.with_context(end);
 }
 
 fn benchmark_request(c: &mut Criterion) {
@@ -16,20 +30,46 @@ fn benchmark_request(c: &mut Criterion) {
         .unwrap();
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let start = StartContext { start_time: std::time::SystemTime::now() };
+    let end = EndContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
     let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(:PATH)%").unwrap();
     c.bench_function("REQ(:PATH)", |b| {
-        b.iter(|| black_box(eval_format(black_box(&request), black_box(&response), fmt.clone())))
+        b.iter(|| {
+            black_box(eval_format(
+                &DownStreamRequest(&request),
+                &DownStreamResponse(&response),
+                &start,
+                &end,
+                fmt.clone(),
+            ))
+        })
     });
 
     let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(:METHOD)%").unwrap();
     c.bench_function("REQ(:METHOD)", |b| {
-        b.iter(|| black_box(eval_format(black_box(&request), black_box(&response), fmt.clone())))
+        b.iter(|| {
+            black_box(eval_format(
+                &DownStreamRequest(&request),
+                &DownStreamResponse(&response),
+                &start,
+                &end,
+                fmt.clone(),
+            ))
+        })
     });
 
     let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(USER-AGENT)%").unwrap();
     c.bench_function("REQ(USER-AGENT)", |b| {
-        b.iter(|| black_box(eval_format(black_box(&request), black_box(&response), fmt.clone())))
+        b.iter(|| {
+            black_box(eval_format(
+                &DownStreamRequest(&request),
+                &DownStreamResponse(&response),
+                &start,
+                &end,
+                fmt.clone(),
+            ))
+        })
     });
 }
 
@@ -41,12 +81,22 @@ fn benchmark_default_format(c: &mut Criterion) {
         .unwrap();
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let start = StartContext { start_time: std::time::SystemTime::now() };
+    let end = EndContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
     let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
     let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
 
     c.bench_function("Envoy default formatter", |b| {
-        b.iter(|| black_box(eval_format(black_box(&request), black_box(&response), fmt.clone())))
+        b.iter(|| {
+            black_box(eval_format(
+                &DownStreamRequest(&request),
+                &DownStreamResponse(&response),
+                &start,
+                &end,
+                fmt.clone(),
+            ))
+        })
     });
 }
 
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 007e5820..a94d1203 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -1,3 +1,6 @@
+use std::time::{Duration, SystemTime};
+
+use chrono::{DateTime, SecondsFormat, Utc};
 use http::{Request, Response, Version};
 use smol_str::{format_smolstr, SmolStr};
 
@@ -8,28 +11,69 @@ pub trait Context {
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>>;
 }
 
-impl<T> Context for Request<T> {
+pub struct StartContext {
+    pub start_time: SystemTime,
+}
+
+pub struct EndContext {
+    pub duration: Duration,
+    pub bytes_received: usize,
+    pub bytes_sent: usize,
+}
+
+impl Context for StartContext {
+    fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
+        match token {
+            Token::StartTime => {
+                let datetime_utc: DateTime<Utc> = self.start_time.into();
+                let fmt_rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
+                Some(SmolCow::Owned(format_smolstr!("{fmt_rfc3339}")))
+            },
+            _ => None,
+        }
+    }
+}
+
+impl Context for EndContext {
+    fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
+        match token {
+            Token::Duration => Some(SmolCow::Owned(format_smolstr!("{}", self.duration.as_millis()))),
+            Token::BytesReceived => Some(SmolCow::Owned(format_smolstr!("{}", self.bytes_received))),
+            Token::BytesSent => Some(SmolCow::Owned(format_smolstr!("{}", self.bytes_sent))),
+            _ => None,
+        }
+    }
+}
+
+pub struct DownStreamRequest<'a, T>(pub &'a Request<T>);
+pub struct UpStreamRequest<'a, T>(pub &'a Request<T>);
+pub struct DownStreamResponse<'a, T>(pub &'a Response<T>);
+pub struct UpStreamResponse<'a, T>(pub &'a Response<T>);
+
+impl<'r, T> Context for DownStreamRequest<'r, T> {
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match (token, arg) {
-            (Token::Request, Some(TokenArgument::Request(ReqArg::Path))) => Some(SmolCow::Borrowed(self.uri().path())),
+            (Token::Request, Some(TokenArgument::Request(ReqArg::Path))) => {
+                Some(SmolCow::Borrowed(self.0.uri().path()))
+            },
             (Token::Request, Some(TokenArgument::Request(ReqArg::Authority))) => {
-                self.uri().authority().and_then(|a| Some(SmolCow::Borrowed(a.host())))
+                self.0.uri().authority().and_then(|a| Some(SmolCow::Borrowed(a.host())))
             },
             (Token::Request, Some(TokenArgument::Request(ReqArg::Method))) => {
-                Some(SmolCow::Borrowed(self.method().as_str()))
+                Some(SmolCow::Borrowed(self.0.method().as_str()))
             },
             (Token::Request, Some(TokenArgument::Request(ReqArg::Scheme))) => {
-                self.uri().scheme().map(|s| SmolCow::Owned(format_smolstr!("{}", s)))
+                self.0.uri().scheme().map(|s| SmolCow::Owned(format_smolstr!("{}", s)))
             },
             (Token::Request, Some(TokenArgument::Request(ReqArg::NormalHeader(h)))) => {
-                let hv = self.headers().get(h);
+                let hv = self.0.headers().get(h);
                 match hv {
                     Some(hv) => hv.to_str().ok().map(SmolCow::Borrowed),
                     None => Some(SmolCow::Borrowed("")),
                 }
             },
             (Token::Protocol, _) => {
-                let ver = match self.version() {
+                let ver = match self.0.version() {
                     Version::HTTP_10 => "HTTP/1.0",
                     Version::HTTP_11 => "HTTP/1.1",
                     Version::HTTP_2 => "HTTP/2",
@@ -44,12 +88,12 @@ impl<T> Context for Request<T> {
     }
 }
 
-impl<T> Context for Response<T> {
+impl<'r, T> Context for DownStreamResponse<'r, T> {
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match (token, arg) {
-            (Token::ResponseCode, _) => Some(SmolCow::Owned(SmolStr::new_inline(self.status().as_str()))),
+            (Token::ResponseCode, _) => Some(SmolCow::Owned(SmolStr::new_inline(self.0.status().as_str()))),
             (Token::Response, Some(TokenArgument::Response(RespArg::NormalHeader(h)))) => {
-                let hv = self.headers().get(h.as_str());
+                let hv = self.0.headers().get(h.as_str());
                 match hv {
                     Some(hv) => hv.to_str().ok().map(SmolCow::Borrowed),
                     None => Some(SmolCow::Borrowed("")),
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 6edf8344..ea91b1ed 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -90,8 +90,12 @@ pub trait Grammar {
 
 #[cfg(test)]
 mod tests {
+    use std::time::Duration;
+
     use http::{Request, Response, StatusCode};
 
+    use crate::context::{DownStreamRequest, DownStreamResponse, EndContext, StartContext};
+
     use super::*;
 
     fn build_request() -> Request<()> {
@@ -108,7 +112,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:PATH)%").unwrap();
         let expected = "/";
-        formatter.with_context(&req);
+        formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -118,7 +122,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:METHOD)%").unwrap();
         let expected = "GET";
-        formatter.with_context(&req);
+        formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -128,7 +132,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:SCHEME)%").unwrap();
         let expected = "https";
-        formatter.with_context(&req);
+        formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -138,7 +142,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:AUTHORITY)%").unwrap();
         let expected = "www.rust-lang.org";
-        formatter.with_context(&req);
+        formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -148,7 +152,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(USER-AGENT)%").unwrap();
         let expected = "awesome/1.0";
-        formatter.with_context(&req);
+        formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -159,8 +163,14 @@ mod tests {
         let resp = build_response();
         let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
         let mut formatter = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
-        formatter.with_context(&req);
-        formatter.with_context(&resp);
+        formatter.with_context(&StartContext { start_time: std::time::SystemTime::now() });
+        formatter.with_context(&DownStreamRequest(&req));
+        formatter.with_context(&DownStreamResponse(&resp));
+        formatter.with_context(&EndContext {
+            duration: Duration::from_millis(100),
+            bytes_received: 128,
+            bytes_sent: 256,
+        });
         let actual = format!("{}", &formatter);
         println!("{}", actual);
     }

From 8f0d50235f533b2999752366a8916127a51136aa Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 13 May 2025 10:48:24 +0200
Subject: [PATCH 14/64] Refactor context structs and add write_to method for
 LogFormatter

- Renamed StartContext to DownStreamContext and EndContext to UpStreamContext.
- Updated benchmarks and tests to use the new context struct names.
- Added a write_to method to LogFormatter for writing formatted output to a writer.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 42 ++++++++++++++++++++++++++-----
 orion-format/src/context.rs       |  8 +++---
 orion-format/src/lib.rs           | 19 +++++++++++---
 3 files changed, 56 insertions(+), 13 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 4f7cdcf5..89e4e602 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -1,7 +1,7 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use http::{Request, Response, StatusCode};
 use orion_format::{
-    context::{Context, DownStreamRequest, DownStreamResponse, EndContext, StartContext},
+    context::{Context, DownStreamContext, DownStreamRequest, DownStreamResponse, UpStreamContext},
     smol_cow::SmolCow,
     FormatType, LogFormatter,
 };
@@ -30,8 +30,8 @@ fn benchmark_request(c: &mut Criterion) {
         .unwrap();
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
-    let start = StartContext { start_time: std::time::SystemTime::now() };
-    let end = EndContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    let start = DownStreamContext { start_time: std::time::SystemTime::now() };
+    let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
     let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(:PATH)%").unwrap();
     c.bench_function("REQ(:PATH)", |b| {
@@ -81,8 +81,8 @@ fn benchmark_default_format(c: &mut Criterion) {
         .unwrap();
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
-    let start = StartContext { start_time: std::time::SystemTime::now() };
-    let end = EndContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    let start = DownStreamContext { start_time: std::time::SystemTime::now() };
+    let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
     let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
     let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
@@ -100,6 +100,36 @@ fn benchmark_default_format(c: &mut Criterion) {
     });
 }
 
+fn benchmark_format_and_write(c: &mut Criterion) {
+    let request = Request::builder()
+        .uri("https://www.rust-lang.org/hello")
+        .header("User-Agent", "my-awesome-agent/1.0")
+        .body(())
+        .unwrap();
+
+    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let start = DownStreamContext { start_time: std::time::SystemTime::now() };
+    let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+
+    let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+    let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
+
+    c.bench_function("Default formatter and write", |b| {
+        b.iter(|| {
+            black_box(eval_format(
+                &DownStreamRequest(&request),
+                &DownStreamResponse(&response),
+                &start,
+                &end,
+                fmt.clone(),
+            ));
+
+            let mut sink = std::io::sink();
+            _ = black_box(|| { fmt.write_to(&mut sink) });
+        })
+    });
+}
+
 fn benchmark_clone_formatter(c: &mut Criterion) {
     let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
     let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
@@ -129,5 +159,5 @@ fn benchmark_small_cow(c: &mut Criterion) {
     });
 }
 
-criterion_group!(benches, benchmark_default_format, benchmark_clone_formatter, benchmark_request, benchmark_small_cow);
+criterion_group!(benches, benchmark_default_format, benchmark_format_and_write, benchmark_clone_formatter, benchmark_request, benchmark_small_cow);
 criterion_main!(benches);
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index a94d1203..85129859 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -11,17 +11,17 @@ pub trait Context {
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>>;
 }
 
-pub struct StartContext {
+pub struct DownStreamContext {
     pub start_time: SystemTime,
 }
 
-pub struct EndContext {
+pub struct UpStreamContext {
     pub duration: Duration,
     pub bytes_received: usize,
     pub bytes_sent: usize,
 }
 
-impl Context for StartContext {
+impl Context for DownStreamContext {
     fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match token {
             Token::StartTime => {
@@ -34,7 +34,7 @@ impl Context for StartContext {
     }
 }
 
-impl Context for EndContext {
+impl Context for UpStreamContext {
     fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match token {
             Token::Duration => Some(SmolCow::Owned(format_smolstr!("{}", self.duration.as_millis()))),
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index ea91b1ed..58aaa1cf 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -6,6 +6,7 @@ pub mod token;
 use context::Context;
 use smol_str::SmolStr;
 use std::fmt::{self, Display, Formatter};
+use std::io::Write;
 use thiserror::Error;
 use token::{Token, TokenArgument};
 
@@ -62,6 +63,18 @@ impl LogFormatter {
 
         self
     }
+
+    pub fn write_to<W: Write>(&self, w: &mut W) -> std::io::Result<usize> {
+        let mut total_bytes = 0;
+        for part in &self.template {
+            total_bytes += match part {
+                Template::Literal(s) => w.write(s.as_bytes())?,
+                Template::Placeholder(orig, _, _) => w.write((format!("{}", orig)).as_bytes())?,
+            };
+        }
+
+        Ok(total_bytes)
+    }
 }
 
 impl Display for LogFormatter {
@@ -94,7 +107,7 @@ mod tests {
 
     use http::{Request, Response, StatusCode};
 
-    use crate::context::{DownStreamRequest, DownStreamResponse, EndContext, StartContext};
+    use crate::context::{DownStreamContext, DownStreamRequest, DownStreamResponse, UpStreamContext};
 
     use super::*;
 
@@ -163,10 +176,10 @@ mod tests {
         let resp = build_response();
         let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
         let mut formatter = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
-        formatter.with_context(&StartContext { start_time: std::time::SystemTime::now() });
+        formatter.with_context(&DownStreamContext { start_time: std::time::SystemTime::now() });
         formatter.with_context(&DownStreamRequest(&req));
         formatter.with_context(&DownStreamResponse(&resp));
-        formatter.with_context(&EndContext {
+        formatter.with_context(&UpStreamContext {
             duration: Duration::from_millis(100),
             bytes_received: 128,
             bytes_sent: 256,

From ccff6580f10e70570ae4a264b136245abfeca4e2 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 13 May 2025 12:09:56 +0200
Subject: [PATCH 15/64] Refactor LogFormatter to remove FormatType and simplify
 try_new method

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 19 +++++++++----------
 orion-format/src/lib.rs           | 28 ++++++++--------------------
 2 files changed, 17 insertions(+), 30 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 89e4e602..36538da9 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -3,11 +3,13 @@ use http::{Request, Response, StatusCode};
 use orion_format::{
     context::{Context, DownStreamContext, DownStreamRequest, DownStreamResponse, UpStreamContext},
     smol_cow::SmolCow,
-    FormatType, LogFormatter,
+    LogFormatter,
 };
 use smol_str::SmolStr;
 use std::time::Duration;
 
+const DEF_FMT : &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+
 #[inline]
 fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, mut fmt: LogFormatter)
 where
@@ -33,7 +35,7 @@ fn benchmark_request(c: &mut Criterion) {
     let start = DownStreamContext { start_time: std::time::SystemTime::now() };
     let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
-    let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(:PATH)%").unwrap();
+    let fmt = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
     c.bench_function("REQ(:PATH)", |b| {
         b.iter(|| {
             black_box(eval_format(
@@ -46,7 +48,7 @@ fn benchmark_request(c: &mut Criterion) {
         })
     });
 
-    let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(:METHOD)%").unwrap();
+    let fmt = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
     c.bench_function("REQ(:METHOD)", |b| {
         b.iter(|| {
             black_box(eval_format(
@@ -59,7 +61,7 @@ fn benchmark_request(c: &mut Criterion) {
         })
     });
 
-    let fmt = LogFormatter::try_new(FormatType::Envoy, "%REQ(USER-AGENT)%").unwrap();
+    let fmt = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
     c.bench_function("REQ(USER-AGENT)", |b| {
         b.iter(|| {
             black_box(eval_format(
@@ -84,8 +86,7 @@ fn benchmark_default_format(c: &mut Criterion) {
     let start = DownStreamContext { start_time: std::time::SystemTime::now() };
     let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
-    let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
-    let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
+    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
 
     c.bench_function("Envoy default formatter", |b| {
         b.iter(|| {
@@ -111,8 +112,7 @@ fn benchmark_format_and_write(c: &mut Criterion) {
     let start = DownStreamContext { start_time: std::time::SystemTime::now() };
     let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
-    let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
-    let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
+    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
 
     c.bench_function("Default formatter and write", |b| {
         b.iter(|| {
@@ -131,8 +131,7 @@ fn benchmark_format_and_write(c: &mut Criterion) {
 }
 
 fn benchmark_clone_formatter(c: &mut Criterion) {
-    let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
-    let fmt = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
+    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
     c.bench_function("Clone formatter", |b| b.iter(|| black_box(fmt.clone())));
 }
 
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 58aaa1cf..ed7d83f6 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -42,14 +42,9 @@ pub struct LogFormatter {
 }
 
 impl LogFormatter {
-    pub fn try_new(typ: FormatType, input: &str) -> Result<LogFormatter, FormatError> {
-        match typ {
-            FormatType::Envoy => {
+    pub fn try_new(input: &str) -> Result<LogFormatter, FormatError> {
                 let template = EnvoyGrammar::parse(input)?;
                 Ok(LogFormatter { template })
-            },
-            FormatType::GridRouter => todo!(),
-        }
     }
 
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
@@ -91,12 +86,6 @@ impl Display for LogFormatter {
     }
 }
 
-#[derive(Debug, PartialEq)]
-pub enum FormatType {
-    Envoy,
-    GridRouter,
-}
-
 pub trait Grammar {
     fn parse(input: &str) -> Result<Vec<Template>, FormatError>;
 }
@@ -123,7 +112,7 @@ mod tests {
     #[test]
     fn test_request_path() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:PATH)%").unwrap();
+        let mut formatter = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
         let expected = "/";
         formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -133,7 +122,7 @@ mod tests {
     #[test]
     fn test_request_method() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:METHOD)%").unwrap();
+        let mut formatter = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
         let expected = "GET";
         formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -143,7 +132,7 @@ mod tests {
     #[test]
     fn test_request_scheme() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:SCHEME)%").unwrap();
+        let mut formatter = LogFormatter::try_new("%REQ(:SCHEME)%").unwrap();
         let expected = "https";
         formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -153,7 +142,7 @@ mod tests {
     #[test]
     fn test_request_authority() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(:AUTHORITY)%").unwrap();
+        let mut formatter = LogFormatter::try_new("%REQ(:AUTHORITY)%").unwrap();
         let expected = "www.rust-lang.org";
         formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -163,7 +152,7 @@ mod tests {
     #[test]
     fn test_request_user_agent() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new(FormatType::Envoy, "%REQ(USER-AGENT)%").unwrap();
+        let mut formatter = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
         let expected = "awesome/1.0";
         formatter.with_context(&DownStreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -175,7 +164,7 @@ mod tests {
         let req = build_request();
         let resp = build_response();
         let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
-        let mut formatter = LogFormatter::try_new(FormatType::Envoy, def_fmt).unwrap();
+        let mut formatter = LogFormatter::try_new(def_fmt).unwrap();
         formatter.with_context(&DownStreamContext { start_time: std::time::SystemTime::now() });
         formatter.with_context(&DownStreamRequest(&req));
         formatter.with_context(&DownStreamResponse(&resp));
@@ -184,7 +173,6 @@ mod tests {
             bytes_received: 128,
             bytes_sent: 256,
         });
-        let actual = format!("{}", &formatter);
-        println!("{}", actual);
+        println!("{}", &formatter);
     }
 }

From 2dd8016eb2147e4b03f6cb48127ecd36bff9ebd4 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 13 May 2025 12:18:50 +0200
Subject: [PATCH 16/64] Minor code improvements.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/envoy.rs | 12 ++++++------
 orion-format/src/lib.rs   |  8 ++++----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/orion-format/src/envoy.rs b/orion-format/src/envoy.rs
index 6bd5eeb8..bcff12ae 100644
--- a/orion-format/src/envoy.rs
+++ b/orion-format/src/envoy.rs
@@ -202,9 +202,9 @@ impl Grammar for EnvoyGrammar {
 
             // finst the longest placeholder starting from the current index i
             //
-            if input[i..].starts_with("%") {
+            if input[i..].starts_with('%') {
                 let remainder = &input[i + 1..];
-                if remainder.starts_with("%") {
+                if remainder.starts_with('%') {
                     skip = Some(2);
                 } else if let Some((placeholder, placeholder_len, has_arg)) =
                     ENVOY_PATTERNS.find_longest_prefix(remainder.bytes())
@@ -217,12 +217,12 @@ impl Grammar for EnvoyGrammar {
                         if longest_placeholder.is_none() || *placeholder_len > longest_placeholder.as_ref().unwrap().1 {
                             match placeholder {
                                 Token::Request => {
-                                    let arg = Self::parse_request(&arg_value)?;
+                                    let arg = Self::parse_request(arg_value)?;
                                     longest_placeholder =
                                         Some((*placeholder, *placeholder_len, Some(TokenArgument::Request(arg))));
                                 },
                                 Token::Response => {
-                                    let arg = Self::parse_response(&arg_value)?;
+                                    let arg = Self::parse_response(arg_value)?;
                                     longest_placeholder =
                                         Some((*placeholder, *placeholder_len, Some(TokenArgument::Response(arg))));
                                 },
@@ -230,14 +230,14 @@ impl Grammar for EnvoyGrammar {
                             }
                         }
 
-                        if !after_placeholder[arg_len..].starts_with("%") {
+                        if !after_placeholder[arg_len..].starts_with('%') {
                             return Err(FormatError::MissingDelimiter(remainder.into()));
                         }
 
                         skip = Some(2 + *placeholder_len + arg_len);
                     } else {
                         longest_placeholder = Some((*placeholder, *placeholder_len, None));
-                        if !after_placeholder.starts_with("%") {
+                        if !after_placeholder.starts_with('%') {
                             return Err(FormatError::MissingDelimiter(remainder.into()));
                         }
                         skip = Some(2 + *placeholder_len);
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index ed7d83f6..b2dd74b9 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -43,8 +43,8 @@ pub struct LogFormatter {
 
 impl LogFormatter {
     pub fn try_new(input: &str) -> Result<LogFormatter, FormatError> {
-                let template = EnvoyGrammar::parse(input)?;
-                Ok(LogFormatter { template })
+        let template = EnvoyGrammar::parse(input)?;
+        Ok(LogFormatter { template })
     }
 
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
@@ -64,7 +64,7 @@ impl LogFormatter {
         for part in &self.template {
             total_bytes += match part {
                 Template::Literal(s) => w.write(s.as_bytes())?,
-                Template::Placeholder(orig, _, _) => w.write((format!("{}", orig)).as_bytes())?,
+                Template::Placeholder(orig, _, _) => w.write(orig.as_bytes())?,
             };
         }
 
@@ -78,7 +78,7 @@ impl Display for LogFormatter {
             match part {
                 Template::Literal(s) => f.write_str(s.as_ref())?,
                 Template::Placeholder(orig, _, _) => {
-                    f.write_str(&format!("{}", orig))?;
+                    f.write_str(orig)?;
                 },
             }
         }

From 2f3e0e0c4156ac6f414b065c132096b15f68f181 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 13 May 2025 15:10:58 +0200
Subject: [PATCH 17/64] Add benchmark for pure rust format!

Includes a new `benchmark_rust_format` function to measure the
performance of pure log formatting.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml           |  8 +++
 orion-format/benches/benchmark.rs | 86 +++++++++++++++++++++++++++++--
 orion-format/src/context.rs       |  6 ++-
 3 files changed, 94 insertions(+), 6 deletions(-)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index ac1ace93..236354c3 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -15,6 +15,14 @@ lazy_static = "1.5.0"
 ptrie = "0.7.2"
 smol_str = "0.3.2"
 chrono = "0.4.40"
+dhat = "0.3.3"
+
+[features]
+dhat-heap = []
+
+[profile.bench]
+inherits = "release"
+debug = true
 
 [[bench]]
 name = "benchmark"
diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 36538da9..891b8112 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -1,5 +1,6 @@
+use chrono::{DateTime, SecondsFormat, Utc};
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use http::{Request, Response, StatusCode};
+use http::{HeaderMap, HeaderName, HeaderValue, Request, Response, StatusCode, Version};
 use orion_format::{
     context::{Context, DownStreamContext, DownStreamRequest, DownStreamResponse, UpStreamContext},
     smol_cow::SmolCow,
@@ -8,7 +9,11 @@ use orion_format::{
 use smol_str::SmolStr;
 use std::time::Duration;
 
-const DEF_FMT : &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+#[cfg(feature = "dhat-heap")]
+#[global_allocator]
+static ALLOC: dhat::Alloc = dhat::Alloc;
+
+const DEF_FMT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
 
 #[inline]
 fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, mut fmt: LogFormatter)
@@ -24,6 +29,68 @@ where
     fmt.with_context(end);
 }
 
+#[inline(always)]
+fn header_lookup(name: &str, m: &HeaderMap) -> HeaderValue {
+    m.get(name).map(HeaderValue::to_owned).unwrap_or(HeaderValue::from_static(""))
+}
+
+fn benchmark_rust_format(c: &mut Criterion) {
+    let request = Request::builder()
+        .uri("https://www.rust-lang.org/hello")
+        .header("User-Agent", "my-awesome-agent/1.0")
+        .body(())
+        .unwrap();
+
+    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let start = DownStreamContext { start_time: std::time::SystemTime::now() };
+    let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+
+    c.bench_function("Pure format!", |b| {
+        b.iter(|| {
+            let start_time = start.start_time.clone();
+            let datetime_utc: DateTime<Utc> = start_time.into();
+            let rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
+
+            let method = request.method().clone();
+            let uri = request.uri().clone();
+
+            let protocol = request.version().clone();
+            let ver = match protocol {
+                Version::HTTP_10 => "HTTP/1.0",
+                Version::HTTP_11 => "HTTP/1.1",
+                Version::HTTP_2 => "HTTP/2",
+                Version::HTTP_3 => "HTTP/3",
+                _ => "HTTP/UNKNOWN",
+            };
+
+            let response_code = response.status().clone();
+            let end_context = end.clone();
+
+            let x_envoy_upstream_service_time = header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers());
+            let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers());
+            let user_agent = header_lookup("USER-AGENT", request.headers());
+            let x_request_id = header_lookup("X-REQUEST-ID", request.headers());
+
+            black_box(format!(
+                r#"[{}] "{} {} {} {} %RESPONSE_FLAGS% {} {} {} {} {} {} {} {} "%UPSTREAM_HOST%""#,
+                rfc3339,
+                method.as_str(),
+                uri.path(),
+                ver,
+                response_code.as_u16(),
+                end_context.bytes_received,
+                end_context.bytes_sent,
+                end_context.duration.as_millis(),
+                x_envoy_upstream_service_time.to_str().unwrap(),
+                x_forwarded_for.to_str().unwrap(),
+                user_agent.to_str().unwrap(),
+                x_request_id.to_str().unwrap(),
+                uri.authority().unwrap().host()
+            ));
+        });
+    });
+}
+
 fn benchmark_request(c: &mut Criterion) {
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")
@@ -76,6 +143,9 @@ fn benchmark_request(c: &mut Criterion) {
 }
 
 fn benchmark_default_format(c: &mut Criterion) {
+    #[cfg(feature = "dhat-heap")]
+    let _profiler = dhat::Profiler::new_heap();
+
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")
         .header("User-Agent", "my-awesome-agent/1.0")
@@ -125,7 +195,7 @@ fn benchmark_format_and_write(c: &mut Criterion) {
             ));
 
             let mut sink = std::io::sink();
-            _ = black_box(|| { fmt.write_to(&mut sink) });
+            _ = black_box(|| fmt.write_to(&mut sink));
         })
     });
 }
@@ -158,5 +228,13 @@ fn benchmark_small_cow(c: &mut Criterion) {
     });
 }
 
-criterion_group!(benches, benchmark_default_format, benchmark_format_and_write, benchmark_clone_formatter, benchmark_request, benchmark_small_cow);
+criterion_group!(
+    benches,
+    benchmark_rust_format,
+    benchmark_default_format,
+    benchmark_format_and_write,
+    benchmark_clone_formatter,
+    benchmark_request,
+    benchmark_small_cow
+);
 criterion_main!(benches);
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 85129859..10641e09 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -11,10 +11,12 @@ pub trait Context {
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>>;
 }
 
+#[derive(Clone, Debug)]
 pub struct DownStreamContext {
     pub start_time: SystemTime,
 }
 
+#[derive(Clone, Debug)]
 pub struct UpStreamContext {
     pub duration: Duration,
     pub bytes_received: usize,
@@ -26,8 +28,8 @@ impl Context for DownStreamContext {
         match token {
             Token::StartTime => {
                 let datetime_utc: DateTime<Utc> = self.start_time.into();
-                let fmt_rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
-                Some(SmolCow::Owned(format_smolstr!("{fmt_rfc3339}")))
+                let rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
+                Some(SmolCow::Owned(rfc3339.into()))
             },
             _ => None,
         }

From 91f851f04388a33b3c1ba07032fdf24e917b11ec Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 13 May 2025 17:39:40 +0200
Subject: [PATCH 18/64] Deprecating the annotation of the orginal placeholder
 for performance reasons.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs |  2 +-
 orion-format/src/envoy.rs         | 38 +++++++++----------------------
 orion-format/src/lib.rs           | 10 ++++----
 3 files changed, 17 insertions(+), 33 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 891b8112..c4e8fb1e 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -1,6 +1,6 @@
 use chrono::{DateTime, SecondsFormat, Utc};
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use http::{HeaderMap, HeaderName, HeaderValue, Request, Response, StatusCode, Version};
+use http::{HeaderMap, HeaderValue, Request, Response, StatusCode, Version};
 use orion_format::{
     context::{Context, DownStreamContext, DownStreamRequest, DownStreamResponse, UpStreamContext},
     smol_cow::SmolCow,
diff --git a/orion-format/src/envoy.rs b/orion-format/src/envoy.rs
index bcff12ae..363d0c41 100644
--- a/orion-format/src/envoy.rs
+++ b/orion-format/src/envoy.rs
@@ -256,7 +256,7 @@ impl Grammar for EnvoyGrammar {
 
                 // Add this placeholder.
                 parts.push(Template::Placeholder(
-                    input[i..i + skip.unwrap()].into(),
+                    // input[i..i + skip.unwrap()].into() <- this is original placeholder
                     placeholder.0.into(),
                     placeholder.2.clone(),
                 ));
@@ -298,10 +298,8 @@ mod tests {
     #[test]
     fn test_parse_only_placeholders() {
         let input = "%START_TIME%%PROTOCOL%";
-        let expected = vec![
-            Template::Placeholder("%START_TIME%".into(), Token::StartTime, None),
-            Template::Placeholder("%PROTOCOL%".into(), Token::Protocol, None),
-        ];
+        let expected =
+            vec![Template::Placeholder(Token::StartTime, None), Template::Placeholder(Token::Protocol, None)];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
@@ -311,13 +309,9 @@ mod tests {
         let input = "Start %REQ(:METHOD)% middle %PROTOCOL% end.";
         let expected = vec![
             Template::Literal("Start ".into()),
-            Template::Placeholder(
-                "%REQ(:METHOD)%".into(),
-                Token::Request,
-                Some(TokenArgument::Request(ReqArg::Method)),
-            ),
+            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Method))),
             Template::Literal(" middle ".into()),
-            Template::Placeholder("%PROTOCOL%".into(), Token::Protocol, None),
+            Template::Placeholder(Token::Protocol, None),
             Template::Literal(" end.".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
@@ -327,10 +321,7 @@ mod tests {
     #[test]
     fn test_parse_starts_with_placeholder() {
         let input = "%START_TIME% literal after.";
-        let expected = vec![
-            Template::Placeholder("%START_TIME%".into(), Token::StartTime, None),
-            Template::Literal(" literal after.".into()),
-        ];
+        let expected = vec![Template::Placeholder(Token::StartTime, None), Template::Literal(" literal after.".into())];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
@@ -338,10 +329,7 @@ mod tests {
     #[test]
     fn test_parse_ends_with_placeholder() {
         let input = "Literal before %PROTOCOL%";
-        let expected = vec![
-            Template::Literal("Literal before ".into()),
-            Template::Placeholder("%PROTOCOL%".into(), Token::Protocol, None),
-        ];
+        let expected = vec![Template::Literal("Literal before ".into()), Template::Placeholder(Token::Protocol, None)];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
@@ -367,17 +355,13 @@ mod tests {
         let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%""#;
         let expected = vec![
             Template::Literal("[".into()),
-            Template::Placeholder("%START_TIME%".into(), Token::StartTime, None),
+            Template::Placeholder(Token::StartTime, None),
             Template::Literal("] \"".into()),
-            Template::Placeholder(
-                "%REQ(:METHOD)%".into(),
-                Token::Request,
-                Some(TokenArgument::Request(ReqArg::Method)),
-            ),
+            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Method))),
             Template::Literal(" ".into()),
-            Template::Placeholder("%REQ(:PATH)%".into(), Token::Request, Some(TokenArgument::Request(ReqArg::Path))),
+            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Path))),
             Template::Literal(" ".into()),
-            Template::Placeholder("%PROTOCOL%".into(), Token::Protocol, None),
+            Template::Placeholder(Token::Protocol, None),
             Template::Literal("\"".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index b2dd74b9..85f3e749 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -33,7 +33,7 @@ pub enum FormatError {
 #[derive(PartialEq, Debug, Clone)]
 pub enum Template {
     Literal(SmolStr),
-    Placeholder(SmolStr, Token, Option<TokenArgument>), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
+    Placeholder(Token, Option<TokenArgument>), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
 }
 
 #[derive(PartialEq, Debug, Clone)]
@@ -49,7 +49,7 @@ impl LogFormatter {
 
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
         for part in &mut self.template {
-            if let Template::Placeholder(_, token, arg) = part {
+            if let Template::Placeholder(token, arg) = part {
                 if let Some(value) = ctx.eval_part(token, arg) {
                     *part = Template::Literal(value.into_owned()); // TODO: Reduce memory allocations by grouping consecutive expanded templates
                 }
@@ -64,7 +64,7 @@ impl LogFormatter {
         for part in &self.template {
             total_bytes += match part {
                 Template::Literal(s) => w.write(s.as_bytes())?,
-                Template::Placeholder(orig, _, _) => w.write(orig.as_bytes())?,
+                Template::Placeholder(_, _) => w.write("UNSUP".as_bytes())?,
             };
         }
 
@@ -77,8 +77,8 @@ impl Display for LogFormatter {
         for part in &self.template {
             match part {
                 Template::Literal(s) => f.write_str(s.as_ref())?,
-                Template::Placeholder(orig, _, _) => {
-                    f.write_str(orig)?;
+                Template::Placeholder(_, _) => {
+                    f.write_str("UNSUP")?;
                 },
             }
         }

From fc755743c69911f7cb1c801f158b9ca02aaed0aa Mon Sep 17 00:00:00 2001
From: Dawid Nowak <dawid.nowak@huawei.com>
Date: Tue, 13 May 2025 20:03:31 +0100
Subject: [PATCH 19/64] Improvements to Rust format bench

Signed-off-by: Dawid Nowak <dawid.nowak@huawei.com>
---
 orion-format/benches/benchmark.rs | 120 ++++++++++++++++++------------
 1 file changed, 71 insertions(+), 49 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index c4e8fb1e..60b23a32 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -30,8 +30,8 @@ where
 }
 
 #[inline(always)]
-fn header_lookup(name: &str, m: &HeaderMap) -> HeaderValue {
-    m.get(name).map(HeaderValue::to_owned).unwrap_or(HeaderValue::from_static(""))
+fn header_lookup<'a>(name: &'a str, m: &'a HeaderMap, default_header: &'a HeaderValue) -> &'a HeaderValue {        
+    m.get(name).unwrap_or(default_header)
 }
 
 fn benchmark_rust_format(c: &mut Criterion) {
@@ -44,53 +44,75 @@ fn benchmark_rust_format(c: &mut Criterion) {
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
     let start = DownStreamContext { start_time: std::time::SystemTime::now() };
     let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    //let mut sink = std::io::sink();
 
-    c.bench_function("Pure format!", |b| {
+    c.bench_function("Rust format formatter", |b| {
         b.iter(|| {
-            let start_time = start.start_time.clone();
-            let datetime_utc: DateTime<Utc> = start_time.into();
-            let rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
-
-            let method = request.method().clone();
-            let uri = request.uri().clone();
-
-            let protocol = request.version().clone();
-            let ver = match protocol {
-                Version::HTTP_10 => "HTTP/1.0",
-                Version::HTTP_11 => "HTTP/1.1",
-                Version::HTTP_2 => "HTTP/2",
-                Version::HTTP_3 => "HTTP/3",
-                _ => "HTTP/UNKNOWN",
-            };
-
-            let response_code = response.status().clone();
-            let end_context = end.clone();
-
-            let x_envoy_upstream_service_time = header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers());
-            let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers());
-            let user_agent = header_lookup("USER-AGENT", request.headers());
-            let x_request_id = header_lookup("X-REQUEST-ID", request.headers());
-
-            black_box(format!(
-                r#"[{}] "{} {} {} {} %RESPONSE_FLAGS% {} {} {} {} {} {} {} {} "%UPSTREAM_HOST%""#,
-                rfc3339,
-                method.as_str(),
-                uri.path(),
-                ver,
-                response_code.as_u16(),
-                end_context.bytes_received,
-                end_context.bytes_sent,
-                end_context.duration.as_millis(),
-                x_envoy_upstream_service_time.to_str().unwrap(),
-                x_forwarded_for.to_str().unwrap(),
-                user_agent.to_str().unwrap(),
-                x_request_id.to_str().unwrap(),
-                uri.authority().unwrap().host()
+            let s = black_box( eval_rust_format(
+                &DownStreamRequest(&request),
+                &DownStreamResponse(&response),
+                &start,
+                &end,                
             ));
-        });
+            let _ = black_box(write_to_format(&mut sink, s.as_bytes()));
+        })
     });
 }
 
+fn write_to_format<W: std::io::Write>(w: &mut W, log: &[u8]) -> std::io::Result<usize> {
+    let len= w.write(log)?;
+    Ok(len)
+
+}
+
+fn eval_rust_format( request: &DownStreamRequest<()>, response: &DownStreamResponse<()>, downstream_context: &DownStreamContext, upstream_context: &UpStreamContext )->String{
+    let request = request.0;
+    let response = response.0;
+    let start_time = &downstream_context.start_time;
+    let datetime_utc: DateTime<Utc> = start_time.clone().into();
+    let rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
+
+    let method = request.method();
+    let uri = request.uri();
+
+    let protocol = request.version();
+    let ver = match protocol {
+        Version::HTTP_10 => "HTTP/1.0",
+        Version::HTTP_11 => "HTTP/1.1",
+        Version::HTTP_2 => "HTTP/2",
+        Version::HTTP_3 => "HTTP/3",
+        _ => "HTTP/UNKNOWN",
+    };
+
+    let response_code = response.status();
+    
+    let default_header:HeaderValue = HeaderValue::from_static("");
+    let x_envoy_upstream_service_time = header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers(),&default_header);
+    let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers(),&default_header);
+    let user_agent = header_lookup("USER-AGENT", request.headers(),&default_header);
+    let x_request_id = header_lookup("X-REQUEST-ID", request.headers(),&default_header);
+
+    format!(
+        r#"[{}] "{} {} {} {} %RESPONSE_FLAGS% {} {} {} {} {} {} {} {} "%UPSTREAM_HOST%""#,
+        rfc3339,
+        method.as_str(),
+        uri.path(),
+        ver,
+        response_code.as_u16(),
+        upstream_context.bytes_received,
+        upstream_context.bytes_sent,
+        upstream_context.duration.as_millis(),
+        x_envoy_upstream_service_time.to_str().unwrap(),
+        x_forwarded_for.to_str().unwrap(),
+        user_agent.to_str().unwrap(),
+        x_request_id.to_str().unwrap(),
+        uri.authority().unwrap().host()
+    )
+
+}
+
+
+
 fn benchmark_request(c: &mut Criterion) {
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")
@@ -157,7 +179,7 @@ fn benchmark_default_format(c: &mut Criterion) {
     let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
-
+    
     c.bench_function("Envoy default formatter", |b| {
         b.iter(|| {
             black_box(eval_format(
@@ -166,9 +188,11 @@ fn benchmark_default_format(c: &mut Criterion) {
                 &start,
                 &end,
                 fmt.clone(),
-            ))
+            ));
         })
     });
+
+    
 }
 
 fn benchmark_format_and_write(c: &mut Criterion) {
@@ -183,7 +207,7 @@ fn benchmark_format_and_write(c: &mut Criterion) {
     let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
-
+    let mut sink = std::io::sink();
     c.bench_function("Default formatter and write", |b| {
         b.iter(|| {
             black_box(eval_format(
@@ -192,9 +216,7 @@ fn benchmark_format_and_write(c: &mut Criterion) {
                 &start,
                 &end,
                 fmt.clone(),
-            ));
-
-            let mut sink = std::io::sink();
+            ));            
             _ = black_box(|| fmt.write_to(&mut sink));
         })
     });

From bd1496426df9393817ee95ca912bdefac6db423d Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Wed, 14 May 2025 05:36:23 +0200
Subject: [PATCH 20/64] Rename envoy module to grammar for clarity

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/{envoy.rs => grammar.rs} | 0
 orion-format/src/lib.rs                   | 4 ++--
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename orion-format/src/{envoy.rs => grammar.rs} (100%)

diff --git a/orion-format/src/envoy.rs b/orion-format/src/grammar.rs
similarity index 100%
rename from orion-format/src/envoy.rs
rename to orion-format/src/grammar.rs
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 85f3e749..d5a7ee8d 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -1,5 +1,5 @@
 pub mod context;
-pub mod envoy;
+pub mod grammar;
 pub mod smol_cow;
 pub mod token;
 
@@ -10,7 +10,7 @@ use std::io::Write;
 use thiserror::Error;
 use token::{Token, TokenArgument};
 
-use crate::envoy::EnvoyGrammar;
+use crate::grammar::EnvoyGrammar;
 
 #[derive(Error, Debug)]
 pub enum FormatError {

From b974180bfd7f0bf82294da377e962fb292b75371 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Wed, 14 May 2025 06:10:28 +0200
Subject: [PATCH 21/64] Optimize benchmark profile for performance

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index 236354c3..bba040b3 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -21,8 +21,16 @@ dhat = "0.3.3"
 dhat-heap = []
 
 [profile.bench]
-inherits = "release"
-debug = true
+opt-level = 3
+lto = true
+codegen-units = 1
+debug = false
+strip = "debuginfo"
+debug-assertions = false
+overflow-checks = false
+panic = 'unwind'
+#incremental = false
+#rpath = false
 
 [[bench]]
 name = "benchmark"

From a1d6d72aa1bcc3461ef09be35d5b2c247f8a3fb8 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Wed, 14 May 2025 06:11:18 +0200
Subject: [PATCH 22/64] Refactor context types and benchmarks for clarity

- Renamed `DownStreamContext` to `InitContext` and `UpStreamContext` to `FinishContext`.
- Renamed `DownStreamRequest`/`DownStreamResponse` to `DownstreamRequest`/`DownstreamResponse`.
- Added `number_keys` method to `Context` trait for optimization.
- Updated benchmarks to reflect new context names and structure.
- Improved `LogFormatter::with_context` to limit token evaluations.
- Adjusted tests to use updated context types and methods

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 85 ++++++++++++++++++++++++-------
 orion-format/src/context.rs       | 33 ++++++++----
 orion-format/src/lib.rs           | 26 ++++++----
 3 files changed, 107 insertions(+), 37 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 60b23a32..f2503674 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -2,7 +2,7 @@ use chrono::{DateTime, SecondsFormat, Utc};
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use http::{HeaderMap, HeaderValue, Request, Response, StatusCode, Version};
 use orion_format::{
-    context::{Context, DownStreamContext, DownStreamRequest, DownStreamResponse, UpStreamContext},
+    context::{Context, DownstreamRequest, DownstreamResponse, FinishContext, InitContext},
     smol_cow::SmolCow,
     LogFormatter,
 };
@@ -175,8 +175,8 @@ fn benchmark_default_format(c: &mut Criterion) {
         .unwrap();
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
-    let start = DownStreamContext { start_time: std::time::SystemTime::now() };
-    let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    let start = InitContext { start_time: std::time::SystemTime::now() };
+    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
     
@@ -195,24 +195,25 @@ fn benchmark_default_format(c: &mut Criterion) {
     
 }
 
-fn benchmark_format_and_write(c: &mut Criterion) {
-    let request = Request::builder()
-        .uri("https://www.rust-lang.org/hello")
-        .header("User-Agent", "my-awesome-agent/1.0")
-        .body(())
-        .unwrap();
+    c.bench_function("LogFormatter: DownstreamResponse", |b| {
+        b.iter(|| {
+            black_box(fmt.clone().with_context(&DownstreamResponse(&response)));
+        })
+    });
 
-    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
-    let start = DownStreamContext { start_time: std::time::SystemTime::now() };
-    let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    c.bench_function("LogFormatter: InitContext", |b| {
+        b.iter(|| {
+            black_box(fmt.clone().with_context(&start));
+        })
+    });
 
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
     let mut sink = std::io::sink();
     c.bench_function("Default formatter and write", |b| {
         b.iter(|| {
             black_box(eval_format(
-                &DownStreamRequest(&request),
-                &DownStreamResponse(&response),
+                &DownstreamRequest(&request),
+                &DownstreamResponse(&response),
                 &start,
                 &end,
                 fmt.clone(),
@@ -227,6 +228,57 @@ fn benchmark_clone_formatter(c: &mut Criterion) {
     c.bench_function("Clone formatter", |b| b.iter(|| black_box(fmt.clone())));
 }
 
+fn benchmark_request_parts(c: &mut Criterion) {
+    let request = Request::builder()
+        .uri("https://www.rust-lang.org/hello")
+        .header("User-Agent", "my-awesome-agent/1.0")
+        .body(())
+        .unwrap();
+
+    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let start = InitContext { start_time: std::time::SystemTime::now() };
+    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+
+    let fmt = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
+    c.bench_function("REQ(:PATH)", |b| {
+        b.iter(|| {
+            black_box(eval_format(
+                &DownstreamRequest(&request),
+                &DownstreamResponse(&response),
+                &start,
+                &end,
+                fmt.clone(),
+            ))
+        })
+    });
+
+    let fmt = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
+    c.bench_function("REQ(:METHOD)", |b| {
+        b.iter(|| {
+            black_box(eval_format(
+                &DownstreamRequest(&request),
+                &DownstreamResponse(&response),
+                &start,
+                &end,
+                fmt.clone(),
+            ))
+        })
+    });
+
+    let fmt = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
+    c.bench_function("REQ(USER-AGENT)", |b| {
+        b.iter(|| {
+            black_box(eval_format(
+                &DownstreamRequest(&request),
+                &DownstreamResponse(&response),
+                &start,
+                &end,
+                fmt.clone(),
+            ))
+        })
+    });
+}
+
 fn ret_small_cow() -> SmolCow<'static> {
     SmolCow::Borrowed("123456789012345678901234567890")
 }
@@ -253,10 +305,9 @@ fn benchmark_small_cow(c: &mut Criterion) {
 criterion_group!(
     benches,
     benchmark_rust_format,
-    benchmark_default_format,
-    benchmark_format_and_write,
+    benchmark_log_formatter,
     benchmark_clone_formatter,
-    benchmark_request,
+    benchmark_request_parts,
     benchmark_small_cow
 );
 criterion_main!(benches);
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 10641e09..cf0175a4 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -9,21 +9,25 @@ use crate::token::{ReqArg, RespArg, Token, TokenArgument};
 
 pub trait Context {
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>>;
+    fn number_keys() -> usize;
 }
 
 #[derive(Clone, Debug)]
-pub struct DownStreamContext {
+pub struct InitContext {
     pub start_time: SystemTime,
 }
 
 #[derive(Clone, Debug)]
-pub struct UpStreamContext {
+pub struct FinishContext {
     pub duration: Duration,
     pub bytes_received: usize,
     pub bytes_sent: usize,
 }
 
-impl Context for DownStreamContext {
+impl Context for InitContext {
+    fn number_keys() -> usize {
+        1
+    }
     fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match token {
             Token::StartTime => {
@@ -36,7 +40,10 @@ impl Context for DownStreamContext {
     }
 }
 
-impl Context for UpStreamContext {
+impl Context for FinishContext {
+    fn number_keys() -> usize {
+        3
+    }
     fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match token {
             Token::Duration => Some(SmolCow::Owned(format_smolstr!("{}", self.duration.as_millis()))),
@@ -47,12 +54,15 @@ impl Context for UpStreamContext {
     }
 }
 
-pub struct DownStreamRequest<'a, T>(pub &'a Request<T>);
-pub struct UpStreamRequest<'a, T>(pub &'a Request<T>);
-pub struct DownStreamResponse<'a, T>(pub &'a Response<T>);
-pub struct UpStreamResponse<'a, T>(pub &'a Response<T>);
+pub struct DownstreamRequest<'a, T>(pub &'a Request<T>);
+pub struct UpstreamRequest<'a, T>(pub &'a Request<T>);
+pub struct DownstreamResponse<'a, T>(pub &'a Response<T>);
+pub struct UpstreamResponse<'a, T>(pub &'a Response<T>);
 
-impl<'r, T> Context for DownStreamRequest<'r, T> {
+impl<'r, T> Context for DownstreamRequest<'r, T> {
+    fn number_keys() -> usize {
+        6
+    }
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match (token, arg) {
             (Token::Request, Some(TokenArgument::Request(ReqArg::Path))) => {
@@ -90,7 +100,10 @@ impl<'r, T> Context for DownStreamRequest<'r, T> {
     }
 }
 
-impl<'r, T> Context for DownStreamResponse<'r, T> {
+impl<'r, T> Context for DownstreamResponse<'r, T> {
+    fn number_keys() -> usize {
+        2
+    }
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match (token, arg) {
             (Token::ResponseCode, _) => Some(SmolCow::Owned(SmolStr::new_inline(self.0.status().as_str()))),
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index d5a7ee8d..f69aa69e 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -48,8 +48,14 @@ impl LogFormatter {
     }
 
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
+        let total_keys = C::number_keys();
+        let mut eval_tokens = 0;
         for part in &mut self.template {
+            if eval_tokens == total_keys {
+                break;
+            }
             if let Template::Placeholder(token, arg) = part {
+                eval_tokens += 1;
                 if let Some(value) = ctx.eval_part(token, arg) {
                     *part = Template::Literal(value.into_owned()); // TODO: Reduce memory allocations by grouping consecutive expanded templates
                 }
@@ -96,7 +102,7 @@ mod tests {
 
     use http::{Request, Response, StatusCode};
 
-    use crate::context::{DownStreamContext, DownStreamRequest, DownStreamResponse, UpStreamContext};
+    use crate::context::{DownstreamRequest, DownstreamResponse, FinishContext, InitContext};
 
     use super::*;
 
@@ -114,7 +120,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
         let expected = "/";
-        formatter.with_context(&DownStreamRequest(&req));
+        formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -124,7 +130,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
         let expected = "GET";
-        formatter.with_context(&DownStreamRequest(&req));
+        formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -134,7 +140,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new("%REQ(:SCHEME)%").unwrap();
         let expected = "https";
-        formatter.with_context(&DownStreamRequest(&req));
+        formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -144,7 +150,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new("%REQ(:AUTHORITY)%").unwrap();
         let expected = "www.rust-lang.org";
-        formatter.with_context(&DownStreamRequest(&req));
+        formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -154,7 +160,7 @@ mod tests {
         let req = build_request();
         let mut formatter = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
         let expected = "awesome/1.0";
-        formatter.with_context(&DownStreamRequest(&req));
+        formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -165,10 +171,10 @@ mod tests {
         let resp = build_response();
         let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
         let mut formatter = LogFormatter::try_new(def_fmt).unwrap();
-        formatter.with_context(&DownStreamContext { start_time: std::time::SystemTime::now() });
-        formatter.with_context(&DownStreamRequest(&req));
-        formatter.with_context(&DownStreamResponse(&resp));
-        formatter.with_context(&UpStreamContext {
+        formatter.with_context(&InitContext { start_time: std::time::SystemTime::now() });
+        formatter.with_context(&DownstreamRequest(&req));
+        formatter.with_context(&DownstreamResponse(&resp));
+        formatter.with_context(&FinishContext {
             duration: Duration::from_millis(100),
             bytes_received: 128,
             bytes_sent: 256,

From d77a712d38eb0063fa0c8aaea8740bbc28880be6 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Wed, 14 May 2025 06:58:50 +0200
Subject: [PATCH 23/64] Benchmark updated.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 146 +++++++++++-------------------
 1 file changed, 51 insertions(+), 95 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index f2503674..f318a296 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -30,7 +30,7 @@ where
 }
 
 #[inline(always)]
-fn header_lookup<'a>(name: &'a str, m: &'a HeaderMap, default_header: &'a HeaderValue) -> &'a HeaderValue {        
+fn header_lookup<'a>(name: &'a str, m: &'a HeaderMap, default_header: &'a HeaderValue) -> &'a HeaderValue {
     m.get(name).unwrap_or(default_header)
 }
 
@@ -42,33 +42,34 @@ fn benchmark_rust_format(c: &mut Criterion) {
         .unwrap();
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
-    let start = DownStreamContext { start_time: std::time::SystemTime::now() };
-    let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
-    //let mut sink = std::io::sink();
+    let start = InitContext { start_time: std::time::SystemTime::now() };
+    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    let mut sink = std::io::sink();
 
-    c.bench_function("Rust format formatter", |b| {
+    c.bench_function("Rust format!", |b| {
         b.iter(|| {
-            let s = black_box( eval_rust_format(
-                &DownStreamRequest(&request),
-                &DownStreamResponse(&response),
-                &start,
-                &end,                
-            ));
-            let _ = black_box(write_to_format(&mut sink, s.as_bytes()));
+            let s =
+                black_box(eval_rust_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end));
+
+            _ = black_box(write_to_format(&mut sink, s.as_bytes()));
         })
     });
 }
 
 fn write_to_format<W: std::io::Write>(w: &mut W, log: &[u8]) -> std::io::Result<usize> {
-    let len= w.write(log)?;
+    let len = w.write(log)?;
     Ok(len)
-
 }
 
-fn eval_rust_format( request: &DownStreamRequest<()>, response: &DownStreamResponse<()>, downstream_context: &DownStreamContext, upstream_context: &UpStreamContext )->String{
+fn eval_rust_format(
+    request: &DownstreamRequest<()>,
+    response: &DownstreamResponse<()>,
+    init_context: &InitContext,
+    finish_context: &FinishContext,
+) -> String {
     let request = request.0;
     let response = response.0;
-    let start_time = &downstream_context.start_time;
+    let start_time = &init_context.start_time;
     let datetime_utc: DateTime<Utc> = start_time.clone().into();
     let rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
 
@@ -85,12 +86,13 @@ fn eval_rust_format( request: &DownStreamRequest<()>, response: &DownStreamRespo
     };
 
     let response_code = response.status();
-    
-    let default_header:HeaderValue = HeaderValue::from_static("");
-    let x_envoy_upstream_service_time = header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers(),&default_header);
-    let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers(),&default_header);
-    let user_agent = header_lookup("USER-AGENT", request.headers(),&default_header);
-    let x_request_id = header_lookup("X-REQUEST-ID", request.headers(),&default_header);
+
+    let default_header: HeaderValue = HeaderValue::from_static("");
+    let x_envoy_upstream_service_time =
+        header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers(), &default_header);
+    let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers(), &default_header);
+    let user_agent = header_lookup("USER-AGENT", request.headers(), &default_header);
+    let x_request_id = header_lookup("X-REQUEST-ID", request.headers(), &default_header);
 
     format!(
         r#"[{}] "{} {} {} {} %RESPONSE_FLAGS% {} {} {} {} {} {} {} {} "%UPSTREAM_HOST%""#,
@@ -99,21 +101,21 @@ fn eval_rust_format( request: &DownStreamRequest<()>, response: &DownStreamRespo
         uri.path(),
         ver,
         response_code.as_u16(),
-        upstream_context.bytes_received,
-        upstream_context.bytes_sent,
-        upstream_context.duration.as_millis(),
+        finish_context.bytes_received,
+        finish_context.bytes_sent,
+        finish_context.duration.as_millis(),
         x_envoy_upstream_service_time.to_str().unwrap(),
         x_forwarded_for.to_str().unwrap(),
         user_agent.to_str().unwrap(),
         x_request_id.to_str().unwrap(),
         uri.authority().unwrap().host()
     )
-
 }
 
+fn benchmark_log_formatter(c: &mut Criterion) {
+    #[cfg(feature = "dhat-heap")]
+    let _profiler = dhat::Profiler::new_heap();
 
-
-fn benchmark_request(c: &mut Criterion) {
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")
         .header("User-Agent", "my-awesome-agent/1.0")
@@ -121,70 +123,41 @@ fn benchmark_request(c: &mut Criterion) {
         .unwrap();
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
-    let start = DownStreamContext { start_time: std::time::SystemTime::now() };
-    let end = UpStreamContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    let start = InitContext { start_time: std::time::SystemTime::now() };
+    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
 
-    let fmt = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
-    c.bench_function("REQ(:PATH)", |b| {
+    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
+    let mut sink = std::io::sink();
+
+    c.bench_function("LogFormatter: DownstreamRequest", |b| {
         b.iter(|| {
-            black_box(eval_format(
-                &DownStreamRequest(&request),
-                &DownStreamResponse(&response),
-                &start,
-                &end,
-                fmt.clone(),
-            ))
+            black_box(fmt.clone().with_context(&DownstreamRequest(&request)));
         })
     });
 
-    let fmt = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
-    c.bench_function("REQ(:METHOD)", |b| {
+    c.bench_function("LogFormatter: DownstreamResponse", |b| {
         b.iter(|| {
-            black_box(eval_format(
-                &DownStreamRequest(&request),
-                &DownStreamResponse(&response),
-                &start,
-                &end,
-                fmt.clone(),
-            ))
+            black_box(fmt.clone().with_context(&DownstreamResponse(&response)));
         })
     });
 
-    let fmt = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
-    c.bench_function("REQ(USER-AGENT)", |b| {
+    c.bench_function("LogFormatter: InitContext", |b| {
         b.iter(|| {
-            black_box(eval_format(
-                &DownStreamRequest(&request),
-                &DownStreamResponse(&response),
-                &start,
-                &end,
-                fmt.clone(),
-            ))
+            black_box(fmt.clone().with_context(&start));
         })
     });
-}
-
-fn benchmark_default_format(c: &mut Criterion) {
-    #[cfg(feature = "dhat-heap")]
-    let _profiler = dhat::Profiler::new_heap();
-
-    let request = Request::builder()
-        .uri("https://www.rust-lang.org/hello")
-        .header("User-Agent", "my-awesome-agent/1.0")
-        .body(())
-        .unwrap();
 
-    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
-    let start = InitContext { start_time: std::time::SystemTime::now() };
-    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    c.bench_function("LogFormatter: FinishContext", |b| {
+        b.iter(|| {
+            black_box(fmt.clone().with_context(&end));
+        })
+    });
 
-    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
-    
-    c.bench_function("Envoy default formatter", |b| {
+    c.bench_function("LogFromatter (full)", |b| {
         b.iter(|| {
             black_box(eval_format(
-                &DownStreamRequest(&request),
-                &DownStreamResponse(&response),
+                &DownstreamRequest(&request),
+                &DownstreamResponse(&response),
                 &start,
                 &end,
                 fmt.clone(),
@@ -192,24 +165,7 @@ fn benchmark_default_format(c: &mut Criterion) {
         })
     });
 
-    
-}
-
-    c.bench_function("LogFormatter: DownstreamResponse", |b| {
-        b.iter(|| {
-            black_box(fmt.clone().with_context(&DownstreamResponse(&response)));
-        })
-    });
-
-    c.bench_function("LogFormatter: InitContext", |b| {
-        b.iter(|| {
-            black_box(fmt.clone().with_context(&start));
-        })
-    });
-
-    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
-    let mut sink = std::io::sink();
-    c.bench_function("Default formatter and write", |b| {
+    c.bench_function("LogFormatter (full) + write", |b| {
         b.iter(|| {
             black_box(eval_format(
                 &DownstreamRequest(&request),
@@ -217,7 +173,7 @@ fn benchmark_default_format(c: &mut Criterion) {
                 &start,
                 &end,
                 fmt.clone(),
-            ));            
+            ));
             _ = black_box(|| fmt.write_to(&mut sink));
         })
     });

From b73234d00bcd113a7eb6d2d4e712328551a17bef Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Wed, 14 May 2025 07:11:57 +0200
Subject: [PATCH 24/64] Add benchmark for full clone in Rust format

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 49 ++++++++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index f318a296..41bc571a 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -50,10 +50,57 @@ fn benchmark_rust_format(c: &mut Criterion) {
         b.iter(|| {
             let s =
                 black_box(eval_rust_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end));
-
             _ = black_box(write_to_format(&mut sink, s.as_bytes()));
         })
     });
+
+    let default_haader_value = HeaderValue::from_static("");
+
+    c.bench_function("Rust format! (full clone)", |b| {
+        b.iter(|| {
+            let start_time = start.start_time.clone();
+            let datetime_utc: DateTime<Utc> = start_time.into();
+            let rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
+
+            let method = request.method().clone();
+            let uri = request.uri().clone();
+
+            let protocol = request.version().clone();
+            let ver = match protocol {
+                Version::HTTP_10 => "HTTP/1.0",
+                Version::HTTP_11 => "HTTP/1.1",
+                Version::HTTP_2 => "HTTP/2",
+                Version::HTTP_3 => "HTTP/3",
+                _ => "HTTP/UNKNOWN",
+            };
+
+            let response_code = response.status().clone();
+            let end_context = end.clone();
+
+            let x_envoy_upstream_service_time =
+                header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers(), &default_haader_value);
+            let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers(), &default_haader_value);
+            let user_agent = header_lookup("USER-AGENT", request.headers(), &default_haader_value);
+            let x_request_id = header_lookup("X-REQUEST-ID", request.headers(), &default_haader_value);
+
+            black_box(format!(
+                r#"[{}] "{} {} {} {} %RESPONSE_FLAGS% {} {} {} {} {} {} {} {} "%UPSTREAM_HOST%""#,
+                rfc3339,
+                method.as_str(),
+                uri.path(),
+                ver,
+                response_code.as_u16(),
+                end_context.bytes_received,
+                end_context.bytes_sent,
+                end_context.duration.as_millis(),
+                x_envoy_upstream_service_time.to_str().unwrap(),
+                x_forwarded_for.to_str().unwrap(),
+                user_agent.to_str().unwrap(),
+                x_request_id.to_str().unwrap(),
+                uri.authority().unwrap().host()
+            ));
+        });
+    });
 }
 
 fn write_to_format<W: std::io::Write>(w: &mut W, log: &[u8]) -> std::io::Result<usize> {

From eefbb4dd9922ae375b6edfade5868396b49f5869 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Wed, 14 May 2025 08:12:15 +0200
Subject: [PATCH 25/64] Add category support to context and grammar parsing

Introduce `Category` bitflags to classify tokens and contexts. Updated
`Context` trait to include a `category` method. Modified grammar and
template parsing to handle categories, ensuring placeholders are only
evaluated for matching contexts.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml     |   1 +
 orion-format/src/context.rs |  15 +-
 orion-format/src/grammar.rs | 327 ++++++++++++++++++++----------------
 orion-format/src/lib.rs     |  17 +-
 orion-format/src/token.rs   |  14 ++
 5 files changed, 217 insertions(+), 157 deletions(-)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index bba040b3..f1c5f7d9 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -16,6 +16,7 @@ ptrie = "0.7.2"
 smol_str = "0.3.2"
 chrono = "0.4.40"
 dhat = "0.3.3"
+bitflags = "2.9.0"
 
 [features]
 dhat-heap = []
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index cf0175a4..6c915fc4 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -5,11 +5,12 @@ use http::{Request, Response, Version};
 use smol_str::{format_smolstr, SmolStr};
 
 use crate::smol_cow::SmolCow;
-use crate::token::{ReqArg, RespArg, Token, TokenArgument};
+use crate::token::{Category, ReqArg, RespArg, Token, TokenArgument};
 
 pub trait Context {
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>>;
     fn number_keys() -> usize;
+    fn category() -> Category;
 }
 
 #[derive(Clone, Debug)]
@@ -28,6 +29,9 @@ impl Context for InitContext {
     fn number_keys() -> usize {
         1
     }
+    fn category() -> Category {
+        Category::INIT_CONTEXT
+    }
     fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match token {
             Token::StartTime => {
@@ -44,6 +48,9 @@ impl Context for FinishContext {
     fn number_keys() -> usize {
         3
     }
+    fn category() -> Category {
+        Category::FINISH_CONTEXT
+    }
     fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match token {
             Token::Duration => Some(SmolCow::Owned(format_smolstr!("{}", self.duration.as_millis()))),
@@ -63,6 +70,9 @@ impl<'r, T> Context for DownstreamRequest<'r, T> {
     fn number_keys() -> usize {
         6
     }
+    fn category() -> Category {
+        Category::DOWNSTREAM_REQUEST
+    }
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match (token, arg) {
             (Token::Request, Some(TokenArgument::Request(ReqArg::Path))) => {
@@ -104,6 +114,9 @@ impl<'r, T> Context for DownstreamResponse<'r, T> {
     fn number_keys() -> usize {
         2
     }
+    fn category() -> Category {
+        Category::DOWNSTREAM_RESPONSE
+    }
     fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match (token, arg) {
             (Token::ResponseCode, _) => Some(SmolCow::Owned(SmolStr::new_inline(self.0.status().as_str()))),
diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index 363d0c41..7ade408a 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -1,151 +1,151 @@
-use crate::token::{ReqArg, RespArg, Token, TokenArgument};
+use crate::token::{Category, ReqArg, RespArg, Token, TokenArgument};
 use crate::{FormatError, Grammar, Template};
 use http::HeaderName;
 use lazy_static::lazy_static;
 use ptrie::Trie;
 
 macro_rules! trie_mapstr {
-    ($trie:expr, $lit:literal, $tok:expr) => {
-        $trie.insert($lit.bytes(), ($tok, $lit.len(), false)); // expand the variadic arguments into the tuple.
+    ($trie:expr, $lit:literal, $tok:expr, $cat:expr) => {
+        $trie.insert($lit.bytes(), ($tok, $cat, $lit.len(), false)); // expand the variadic arguments into the tuple.
     };
-    ($trie:expr, $lit:literal, $tok:expr, $arg:expr ) => {
-        $trie.insert($lit.bytes(), ($tok, $lit.len(), $arg)); // expand the variadic arguments into the tuple.
+    ($trie:expr, $lit:literal, $tok:expr, $cat:expr, $arg:expr ) => {
+        $trie.insert($lit.bytes(), ($tok, $cat, $lit.len(), $arg)); // expand the variadic arguments into the tuple.
     };
 }
 
 lazy_static! {
-    static ref ENVOY_REQ_ARGS: Trie<u8, (ReqArg, usize, bool)> = {
+    static ref ENVOY_REQ_ARGS: Trie<u8, (ReqArg, Category, usize, bool)> = {
         let mut trie = Trie::new();
-        trie_mapstr!(trie, ":SCHEME",ReqArg::Scheme);
-        trie_mapstr!(trie, ":METHOD",ReqArg::Method);
-        trie_mapstr!(trie, ":PATH", ReqArg::Path);
-        trie_mapstr!(trie, ":AUTHORITY",ReqArg::Authority);
+        trie_mapstr!(trie, ":SCHEME",ReqArg::Scheme, Category::ARGUMENT);
+        trie_mapstr!(trie, ":METHOD",ReqArg::Method, Category::ARGUMENT);
+        trie_mapstr!(trie, ":PATH", ReqArg::Path, Category::ARGUMENT);
+        trie_mapstr!(trie, ":AUTHORITY",ReqArg::Authority, Category::ARGUMENT);
         trie
     };
 
-    static ref ENVOY_RESP_ARGS: Trie<u8, (RespArg, usize, bool)> = {
+    static ref ENVOY_RESP_ARGS: Trie<u8, (RespArg, Category, usize, bool)> = {
         let trie = Trie::new();
         trie
     };
 
-    static ref ENVOY_PATTERNS: Trie<u8, (Token, usize, bool)> = {
+    static ref ENVOY_PATTERNS: Trie<u8, (Token, Category, usize, bool)> = {
         let mut trie = Trie::new();
-        trie_mapstr!(trie, "REQUEST_DURATION", Token::RequestDuration);
-        trie_mapstr!(trie, "REQUEST_TX_DURATION", Token::RequestTxDuration);
-        trie_mapstr!(trie, "RESPONSE_DURATION", Token::ResponseDuration);
-        trie_mapstr!(trie, "RESPONSE_TX_DURATION", Token::ResponseTxDuration);
-        trie_mapstr!(trie, "DOWNSTREAM_HANDSHAKE_DURATION", Token::DownstreamHandshakeDuration);
-        trie_mapstr!(trie, "ROUNDTRIP_DURATION", Token::RoundtripDuration);
-        trie_mapstr!(trie, "BYTES_RECEIVED", Token::BytesReceived);
-        trie_mapstr!(trie, "BYTES_RETRANSMITTED", Token::BytesRetransmitted);
-        trie_mapstr!(trie, "PACKETS_RETRANSMITTED", Token::PacketsRetransmitted);
-        trie_mapstr!(trie, "UPSTREAM_WIRE_BYTES_RECEIVED", Token::UpstreamWireBytesReceived);
-        trie_mapstr!(trie, "UPSTREAM_HEADER_BYTES_RECEIVED", Token::UpstreamHeaderBytesReceived);
-        trie_mapstr!(trie, "DOWNSTREAM_WIRE_BYTES_RECEIVED", Token::DownstreamWireBytesReceived);
-        trie_mapstr!(trie, "DOWNSTREAM_HEADER_BYTES_RECEIVED", Token::DownstreamHeaderBytesReceived);
-        trie_mapstr!(trie, "PROTOCOL", Token::Protocol);
-        trie_mapstr!(trie, "UPSTREAM_PROTOCOL", Token::UpstreamProtocol);
-        trie_mapstr!(trie, "RESPONSE_CODE", Token::ResponseCode);
-        trie_mapstr!(trie, "RESPONSE_CODE_DETAILS", Token::ResponseCodeDetails);
-        trie_mapstr!(trie, "CONNECTION_TERMINATION_DETAILS", Token::ConnectionTerminationDetails);
-        trie_mapstr!(trie, "BYTES_SENT", Token::BytesSent);
-        trie_mapstr!(trie, "UPSTREAM_WIRE_BYTES_SENT", Token::UpstreamWireBytesSent);
-        trie_mapstr!(trie, "UPSTREAM_HEADER_BYTES_SENT", Token::UpstreamHeaderBytesSent);
-        trie_mapstr!(trie, "DOWNSTREAM_WIRE_BYTES_SENT", Token::DownstreamWireBytesSent);
-        trie_mapstr!(trie, "DOWNSTREAM_HEADER_BYTES_SENT", Token::DownstreamHeaderBytesSent);
-        trie_mapstr!(trie, "DURATION", Token::Duration);
-        trie_mapstr!(trie, "COMMON_DURATION", Token::CommonDuration);
-        trie_mapstr!(trie, "CUSTOM_FLAGS", Token::CustomFlags);
-        trie_mapstr!(trie, "RESPONSE_FLAGS", Token::ResponseFlags);
-        trie_mapstr!(trie, "RESPONSE_FLAGS_LONG", Token::ResponseFlagsLong);
-        trie_mapstr!(trie, "UPSTREAM_HOST_NAME", Token::UpstreamHostName);
-        trie_mapstr!(trie, "UPSTREAM_HOST_NAME_WITHOUT_PORT", Token::UpstreamHostNameWithoutPort);
-        trie_mapstr!(trie, "UPSTREAM_HOST", Token::UpstreamHost);
-        trie_mapstr!(trie, "UPSTREAM_CONNECTION_ID", Token::UpstreamConnectionId);
-        trie_mapstr!(trie, "UPSTREAM_CLUSTER", Token::UpstreamCluster);
-        trie_mapstr!(trie, "UPSTREAM_CLUSTER_RAW", Token::UpstreamClusterRaw);
-        trie_mapstr!(trie, "UPSTREAM_LOCAL_ADDRESS", Token::UpstreamLocalAddress);
-        trie_mapstr!(trie, "UPSTREAM_LOCAL_ADDRESS_WITHOUT_PORT", Token::UpstreamLocalAddressWithoutPort);
-        trie_mapstr!(trie, "UPSTREAM_LOCAL_PORT", Token::UpstreamLocalPort);
-        trie_mapstr!(trie, "UPSTREAM_REMOTE_ADDRESS", Token::UpstreamRemoteAddress);
-        trie_mapstr!(trie, "UPSTREAM_REMOTE_ADDRESS_WITHOUT_PORT", Token::UpstreamRemoteAddressWithoutPort);
-        trie_mapstr!(trie, "UPSTREAM_REMOTE_PORT", Token::UpstreamRemotePort);
-        trie_mapstr!(trie, "UPSTREAM_REQUEST_ATTEMPT_COUNT", Token::UpstreamRequestAttemptCount);
-        trie_mapstr!(trie, "UPSTREAM_TLS_CIPHER", Token::UpstreamTlsCipher);
-        trie_mapstr!(trie, "UPSTREAM_TLS_VERSION", Token::UpstreamTlsVersion);
-        trie_mapstr!(trie, "UPSTREAM_TLS_SESSION_ID", Token::UpstreamTlsSessionId);
-        trie_mapstr!(trie, "UPSTREAM_PEER_ISSUER", Token::UpstreamPeerIssuer);
-        trie_mapstr!(trie, "UPSTREAM_PEER_CERT", Token::UpstreamPeerCert);
-        trie_mapstr!(trie, "UPSTREAM_PEER_SUBJECT", Token::UpstreamPeerSubject);
-        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_ADDRESS", Token::DownstreamLocalAddress);
-        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_LOCAL_ADDRESS", Token::DownstreamDirectLocalAddress);
-        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_ADDRESS_WITHOUT_PORT", Token::DownstreamLocalAddressWithoutPort);
-        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_LOCAL_ADDRESS_WITHOUT_PORT", Token::DownstreamDirectLocalAddressWithoutPort);
-        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_PORT", Token::DownstreamLocalPort);
-        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_LOCAL_PORT", Token::DownstreamDirectLocalPort);
-        trie_mapstr!(trie, "DOWNSTREAM_REMOTE_ADDRESS", Token::DownstreamRemoteAddress);
-        trie_mapstr!(trie, "DOWNSTREAM_REMOTE_ADDRESS_WITHOUT_PORT", Token::DownstreamRemoteAddressWithoutPort);
-        trie_mapstr!(trie, "DOWNSTREAM_REMOTE_PORT", Token::DownstreamRemotePort);
-        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_REMOTE_ADDRESS", Token::DownstreamDirectRemoteAddress);
-        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_REMOTE_ADDRESS_WITHOUT_PORT", Token::DownstreamDirectRemoteAddressWithoutPort);
-        trie_mapstr!(trie, "DOWNSTREAM_DIRECT_REMOTE_PORT", Token::DownstreamDirectRemotePort);
-        trie_mapstr!(trie, "CONNECTION_ID", Token::ConnectionId);
-        trie_mapstr!(trie, "REQUESTED_SERVER_NAME", Token::RequestedServerName);
-        trie_mapstr!(trie, "ROUTE_NAME", Token::RouteName);
-        trie_mapstr!(trie, "UPSTREAM_PEER_URI_SAN", Token::UpstreamPeerUriSan);
-        trie_mapstr!(trie, "UPSTREAM_PEER_DNS_SAN", Token::UpstreamPeerDnsSan);
-        trie_mapstr!(trie, "UPSTREAM_PEER_IP_SAN", Token::UpstreamPeerIpSan);
-        trie_mapstr!(trie, "UPSTREAM_LOCAL_URI_SAN", Token::UpstreamLocalUriSan);
-        trie_mapstr!(trie, "UPSTREAM_LOCAL_DNS_SAN", Token::UpstreamLocalDnsSan);
-        trie_mapstr!(trie, "UPSTREAM_LOCAL_IP_SAN", Token::UpstreamLocalIpSan);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_URI_SAN", Token::DownstreamPeerUriSan);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_DNS_SAN", Token::DownstreamPeerDnsSan);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_IP_SAN", Token::DownstreamPeerIpSan);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_EMAIL_SAN", Token::DownstreamPeerEmailSan);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_OTHERNAME_SAN", Token::DownstreamPeerOthernameSan);
-        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_URI_SAN", Token::DownstreamLocalUriSan);
-        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_DNS_SAN", Token::DownstreamLocalDnsSan);
-        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_IP_SAN", Token::DownstreamLocalIpSan);
-        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_EMAIL_SAN", Token::DownstreamLocalEmailSan);
-        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_OTHERNAME_SAN", Token::DownstreamLocalOthernameSan);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_SUBJECT", Token::DownstreamPeerSubject);
-        trie_mapstr!(trie, "DOWNSTREAM_LOCAL_SUBJECT", Token::DownstreamLocalSubject);
-        trie_mapstr!(trie, "DOWNSTREAM_TLS_SESSION_ID", Token::DownstreamTlsSessionId);
-        trie_mapstr!(trie, "DOWNSTREAM_TLS_CIPHER", Token::DownstreamTlsCipher);
-        trie_mapstr!(trie, "DOWNSTREAM_TLS_VERSION", Token::DownstreamTlsVersion);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_FINGERPRINT_256", Token::DownstreamPeerFingerprint256);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_FINGERPRINT_1", Token::DownstreamPeerFingerprint1);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_SERIAL", Token::DownstreamPeerSerial);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_CHAIN_FINGERPRINTS_256", Token::DownstreamPeerChainFingerprints256);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_CHAIN_FINGERPRINTS_1", Token::DownstreamPeerChainFingerprints1);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_CHAIN_SERIALS", Token::DownstreamPeerChainSerials);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_ISSUER", Token::DownstreamPeerIssuer);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_CERT", Token::DownstreamPeerCert);
-        trie_mapstr!(trie, "DOWNSTREAM_TRANSPORT_FAILURE_REASON", Token::DownstreamTransportFailureReason);
-        trie_mapstr!(trie, "UPSTREAM_TRANSPORT_FAILURE_REASON", Token::UpstreamTransportFailureReason);
-        trie_mapstr!(trie, "HOSTNAME", Token::Hostname);
-        trie_mapstr!(trie, "FILTER_CHAIN_NAME", Token::FilterChainName);
-        trie_mapstr!(trie, "VIRTUAL_CLUSTER_NAME", Token::VirtualClusterName);
-        trie_mapstr!(trie, "TLS_JA3_FINGERPRINT", Token::TlsJa3Fingerprint);
-        trie_mapstr!(trie, "UNIQUE_ID", Token::UniqueId);
-        trie_mapstr!(trie, "STREAM_ID", Token::StreamId);
-        trie_mapstr!(trie, "START_TIME", Token::StartTime);
-        trie_mapstr!(trie, "START_TIME_LOCAL", Token::StartTimeLocal);
-        trie_mapstr!(trie, "EMIT_TIME", Token::EmitTime);
-        trie_mapstr!(trie, "EMIT_TIME_LOCAL", Token::EmitTimeLocal);
-        trie_mapstr!(trie, "DYNAMIC_METADATA", Token::DynamicMetadata);
-        trie_mapstr!(trie, "CLUSTER_METADATA", Token::ClusterMetadata);
-        trie_mapstr!(trie, "UPSTREAM_METADATA", Token::UpstreamMetadata);
-        trie_mapstr!(trie, "FILTER_STATE", Token::FilterState);
-        trie_mapstr!(trie, "UPSTREAM_FILTER_STATE", Token::UpstreamFilterState);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_CERT_V_START", Token::DownstreamPeerCertVStart);
-        trie_mapstr!(trie, "DOWNSTREAM_PEER_CERT_V_END", Token::DownstreamPeerCertVEnd);
-        trie_mapstr!(trie, "UPSTREAM_PEER_CERT_V_START", Token::UpstreamPeerCertVStart);
-        trie_mapstr!(trie, "UPSTREAM_PEER_CERT_V_END", Token::UpstreamPeerCertVEnd);
-        trie_mapstr!(trie, "ENVIRONMENT", Token::Environment);
-        trie_mapstr!(trie, "UPSTREAM_CONNECTION_POOL_READY_DURATION", Token::UpstreamConnectionPoolReadyDuration);
-        trie_mapstr!(trie, "REQ", Token::Request, true); // %REQ(USER-AGENT)%
-        trie_mapstr!(trie, "RESP", Token::Response, true); // %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)%
+        // trie_mapstr!(trie, "REQUEST_DURATION", Token::RequestDuration);
+        // trie_mapstr!(trie, "REQUEST_TX_DURATION", Token::RequestTxDuration);
+        // trie_mapstr!(trie, "RESPONSE_DURATION", Token::ResponseDuration);
+        // trie_mapstr!(trie, "RESPONSE_TX_DURATION", Token::ResponseTxDuration);
+        // trie_mapstr!(trie, "DOWNSTREAM_HANDSHAKE_DURATION", Token::DownstreamHandshakeDuration);
+        // trie_mapstr!(trie, "ROUNDTRIP_DURATION", Token::RoundtripDuration);
+        trie_mapstr!(trie, "BYTES_RECEIVED", Token::BytesReceived, Category::FINISH_CONTEXT);
+        // trie_mapstr!(trie, "BYTES_RETRANSMITTED", Token::BytesRetransmitted);
+        // trie_mapstr!(trie, "PACKETS_RETRANSMITTED", Token::PacketsRetransmitted);
+        // trie_mapstr!(trie, "UPSTREAM_WIRE_BYTES_RECEIVED", Token::UpstreamWireBytesReceived);
+        // trie_mapstr!(trie, "UPSTREAM_HEADER_BYTES_RECEIVED", Token::UpstreamHeaderBytesReceived);
+        // trie_mapstr!(trie, "DOWNSTREAM_WIRE_BYTES_RECEIVED", Token::DownstreamWireBytesReceived);
+        // trie_mapstr!(trie, "DOWNSTREAM_HEADER_BYTES_RECEIVED", Token::DownstreamHeaderBytesReceived);
+        trie_mapstr!(trie, "PROTOCOL", Token::Protocol, Category::DOWNSTREAM_REQUEST);
+        // trie_mapstr!(trie, "UPSTREAM_PROTOCOL", Token::UpstreamProtocol);
+        trie_mapstr!(trie, "RESPONSE_CODE", Token::ResponseCode, Category::DOWNSTREAM_RESPONSE);
+        // trie_mapstr!(trie, "RESPONSE_CODE_DETAILS", Token::ResponseCodeDetails);
+        // trie_mapstr!(trie, "CONNECTION_TERMINATION_DETAILS", Token::ConnectionTerminationDetails);
+        trie_mapstr!(trie, "BYTES_SENT", Token::BytesSent, Category::FINISH_CONTEXT);
+        // trie_mapstr!(trie, "UPSTREAM_WIRE_BYTES_SENT", Token::UpstreamWireBytesSent);
+        // trie_mapstr!(trie, "UPSTREAM_HEADER_BYTES_SENT", Token::UpstreamHeaderBytesSent);
+        // trie_mapstr!(trie, "DOWNSTREAM_WIRE_BYTES_SENT", Token::DownstreamWireBytesSent);
+        // trie_mapstr!(trie, "DOWNSTREAM_HEADER_BYTES_SENT", Token::DownstreamHeaderBytesSent);
+        trie_mapstr!(trie, "DURATION", Token::Duration, Category::FINISH_CONTEXT);
+        // trie_mapstr!(trie, "COMMON_DURATION", Token::CommonDuration);
+        // trie_mapstr!(trie, "CUSTOM_FLAGS", Token::CustomFlags);
+        trie_mapstr!(trie, "RESPONSE_FLAGS", Token::ResponseFlags, Category::FINISH_CONTEXT);
+        // trie_mapstr!(trie, "RESPONSE_FLAGS_LONG", Token::ResponseFlagsLong);
+        // trie_mapstr!(trie, "UPSTREAM_HOST_NAME", Token::UpstreamHostName);
+        // trie_mapstr!(trie, "UPSTREAM_HOST_NAME_WITHOUT_PORT", Token::UpstreamHostNameWithoutPort);
+        trie_mapstr!(trie, "UPSTREAM_HOST", Token::UpstreamHost, Category::UPSTREAM_REQUEST);
+        // trie_mapstr!(trie, "UPSTREAM_CONNECTION_ID", Token::UpstreamConnectionId);
+        // trie_mapstr!(trie, "UPSTREAM_CLUSTER", Token::UpstreamCluster);
+        // trie_mapstr!(trie, "UPSTREAM_CLUSTER_RAW", Token::UpstreamClusterRaw);
+        // trie_mapstr!(trie, "UPSTREAM_LOCAL_ADDRESS", Token::UpstreamLocalAddress);
+        // trie_mapstr!(trie, "UPSTREAM_LOCAL_ADDRESS_WITHOUT_PORT", Token::UpstreamLocalAddressWithoutPort);
+        // trie_mapstr!(trie, "UPSTREAM_LOCAL_PORT", Token::UpstreamLocalPort);
+        // trie_mapstr!(trie, "UPSTREAM_REMOTE_ADDRESS", Token::UpstreamRemoteAddress);
+        // trie_mapstr!(trie, "UPSTREAM_REMOTE_ADDRESS_WITHOUT_PORT", Token::UpstreamRemoteAddressWithoutPort);
+        // trie_mapstr!(trie, "UPSTREAM_REMOTE_PORT", Token::UpstreamRemotePort);
+        // trie_mapstr!(trie, "UPSTREAM_REQUEST_ATTEMPT_COUNT", Token::UpstreamRequestAttemptCount);
+        // trie_mapstr!(trie, "UPSTREAM_TLS_CIPHER", Token::UpstreamTlsCipher);
+        // trie_mapstr!(trie, "UPSTREAM_TLS_VERSION", Token::UpstreamTlsVersion);
+        // trie_mapstr!(trie, "UPSTREAM_TLS_SESSION_ID", Token::UpstreamTlsSessionId);
+        // trie_mapstr!(trie, "UPSTREAM_PEER_ISSUER", Token::UpstreamPeerIssuer);
+        // trie_mapstr!(trie, "UPSTREAM_PEER_CERT", Token::UpstreamPeerCert);
+        // trie_mapstr!(trie, "UPSTREAM_PEER_SUBJECT", Token::UpstreamPeerSubject);
+        // trie_mapstr!(trie, "DOWNSTREAM_LOCAL_ADDRESS", Token::DownstreamLocalAddress);
+        // trie_mapstr!(trie, "DOWNSTREAM_DIRECT_LOCAL_ADDRESS", Token::DownstreamDirectLocalAddress);
+        // trie_mapstr!(trie, "DOWNSTREAM_LOCAL_ADDRESS_WITHOUT_PORT", Token::DownstreamLocalAddressWithoutPort);
+        // trie_mapstr!(trie, "DOWNSTREAM_DIRECT_LOCAL_ADDRESS_WITHOUT_PORT", Token::DownstreamDirectLocalAddressWithoutPort);
+        // trie_mapstr!(trie, "DOWNSTREAM_LOCAL_PORT", Token::DownstreamLocalPort);
+        // trie_mapstr!(trie, "DOWNSTREAM_DIRECT_LOCAL_PORT", Token::DownstreamDirectLocalPort);
+        // trie_mapstr!(trie, "DOWNSTREAM_REMOTE_ADDRESS", Token::DownstreamRemoteAddress);
+        // trie_mapstr!(trie, "DOWNSTREAM_REMOTE_ADDRESS_WITHOUT_PORT", Token::DownstreamRemoteAddressWithoutPort);
+        // trie_mapstr!(trie, "DOWNSTREAM_REMOTE_PORT", Token::DownstreamRemotePort);
+        // trie_mapstr!(trie, "DOWNSTREAM_DIRECT_REMOTE_ADDRESS", Token::DownstreamDirectRemoteAddress);
+        // trie_mapstr!(trie, "DOWNSTREAM_DIRECT_REMOTE_ADDRESS_WITHOUT_PORT", Token::DownstreamDirectRemoteAddressWithoutPort);
+        // trie_mapstr!(trie, "DOWNSTREAM_DIRECT_REMOTE_PORT", Token::DownstreamDirectRemotePort);
+        // trie_mapstr!(trie, "CONNECTION_ID", Token::ConnectionId);
+        // trie_mapstr!(trie, "REQUESTED_SERVER_NAME", Token::RequestedServerName);
+        // trie_mapstr!(trie, "ROUTE_NAME", Token::RouteName);
+        // trie_mapstr!(trie, "UPSTREAM_PEER_URI_SAN", Token::UpstreamPeerUriSan);
+        // trie_mapstr!(trie, "UPSTREAM_PEER_DNS_SAN", Token::UpstreamPeerDnsSan);
+        // trie_mapstr!(trie, "UPSTREAM_PEER_IP_SAN", Token::UpstreamPeerIpSan);
+        // trie_mapstr!(trie, "UPSTREAM_LOCAL_URI_SAN", Token::UpstreamLocalUriSan);
+        // trie_mapstr!(trie, "UPSTREAM_LOCAL_DNS_SAN", Token::UpstreamLocalDnsSan);
+        // trie_mapstr!(trie, "UPSTREAM_LOCAL_IP_SAN", Token::UpstreamLocalIpSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_URI_SAN", Token::DownstreamPeerUriSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_DNS_SAN", Token::DownstreamPeerDnsSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_IP_SAN", Token::DownstreamPeerIpSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_EMAIL_SAN", Token::DownstreamPeerEmailSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_OTHERNAME_SAN", Token::DownstreamPeerOthernameSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_LOCAL_URI_SAN", Token::DownstreamLocalUriSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_LOCAL_DNS_SAN", Token::DownstreamLocalDnsSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_LOCAL_IP_SAN", Token::DownstreamLocalIpSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_LOCAL_EMAIL_SAN", Token::DownstreamLocalEmailSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_LOCAL_OTHERNAME_SAN", Token::DownstreamLocalOthernameSan);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_SUBJECT", Token::DownstreamPeerSubject);
+        // trie_mapstr!(trie, "DOWNSTREAM_LOCAL_SUBJECT", Token::DownstreamLocalSubject);
+        // trie_mapstr!(trie, "DOWNSTREAM_TLS_SESSION_ID", Token::DownstreamTlsSessionId);
+        // trie_mapstr!(trie, "DOWNSTREAM_TLS_CIPHER", Token::DownstreamTlsCipher);
+        // trie_mapstr!(trie, "DOWNSTREAM_TLS_VERSION", Token::DownstreamTlsVersion);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_FINGERPRINT_256", Token::DownstreamPeerFingerprint256);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_FINGERPRINT_1", Token::DownstreamPeerFingerprint1);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_SERIAL", Token::DownstreamPeerSerial);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_CHAIN_FINGERPRINTS_256", Token::DownstreamPeerChainFingerprints256);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_CHAIN_FINGERPRINTS_1", Token::DownstreamPeerChainFingerprints1);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_CHAIN_SERIALS", Token::DownstreamPeerChainSerials);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_ISSUER", Token::DownstreamPeerIssuer);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_CERT", Token::DownstreamPeerCert);
+        // trie_mapstr!(trie, "DOWNSTREAM_TRANSPORT_FAILURE_REASON", Token::DownstreamTransportFailureReason);
+        // trie_mapstr!(trie, "UPSTREAM_TRANSPORT_FAILURE_REASON", Token::UpstreamTransportFailureReason);
+        // trie_mapstr!(trie, "HOSTNAME", Token::Hostname);
+        // trie_mapstr!(trie, "FILTER_CHAIN_NAME", Token::FilterChainName);
+        // trie_mapstr!(trie, "VIRTUAL_CLUSTER_NAME", Token::VirtualClusterName);
+        // trie_mapstr!(trie, "TLS_JA3_FINGERPRINT", Token::TlsJa3Fingerprint);
+        // trie_mapstr!(trie, "UNIQUE_ID", Token::UniqueId);
+        // trie_mapstr!(trie, "STREAM_ID", Token::StreamId);
+        trie_mapstr!(trie, "START_TIME", Token::StartTime, Category::INIT_CONTEXT);
+        // trie_mapstr!(trie, "START_TIME_LOCAL", Token::StartTimeLocal);
+        // trie_mapstr!(trie, "EMIT_TIME", Token::EmitTime);
+        // trie_mapstr!(trie, "EMIT_TIME_LOCAL", Token::EmitTimeLocal);
+        // trie_mapstr!(trie, "DYNAMIC_METADATA", Token::DynamicMetadata);
+        // trie_mapstr!(trie, "CLUSTER_METADATA", Token::ClusterMetadata);
+        // trie_mapstr!(trie, "UPSTREAM_METADATA", Token::UpstreamMetadata);
+        // trie_mapstr!(trie, "FILTER_STATE", Token::FilterState);
+        // trie_mapstr!(trie, "UPSTREAM_FILTER_STATE", Token::UpstreamFilterState);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_CERT_V_START", Token::DownstreamPeerCertVStart);
+        // trie_mapstr!(trie, "DOWNSTREAM_PEER_CERT_V_END", Token::DownstreamPeerCertVEnd);
+        // trie_mapstr!(trie, "UPSTREAM_PEER_CERT_V_START", Token::UpstreamPeerCertVStart);
+        // trie_mapstr!(trie, "UPSTREAM_PEER_CERT_V_END", Token::UpstreamPeerCertVEnd);
+        // trie_mapstr!(trie, "ENVIRONMENT", Token::Environment);
+        // trie_mapstr!(trie, "UPSTREAM_CONNECTION_POOL_READY_DURATION", Token::UpstreamConnectionPoolReadyDuration);
+        trie_mapstr!(trie, "REQ", Token::Request, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST, true); // %REQ(USER-AGENT)%
+        trie_mapstr!(trie, "RESP", Token::Response, Category::DOWNSTREAM_RESPONSE | Category::UPSTREAM_RESPONSE , true); // %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)%
         trie
     };
 }
@@ -155,7 +155,7 @@ pub struct EnvoyGrammar;
 impl EnvoyGrammar {
     fn parse_request(arg: &str) -> Result<ReqArg, FormatError> {
         match ENVOY_REQ_ARGS.find_longest_prefix(arg.bytes()) {
-            Some((t, _, _)) => Ok(t.clone()),
+            Some((t, _, _, _)) => Ok(t.clone()),
             None => {
                 let name =
                     HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidRequestArg(arg.into()))?;
@@ -166,7 +166,7 @@ impl EnvoyGrammar {
 
     fn parse_response(arg: &str) -> Result<RespArg, FormatError> {
         match ENVOY_RESP_ARGS.find_longest_prefix(arg.bytes()) {
-            Some((t, _, _)) => Ok(t.clone()),
+            Some((t, _, _, _)) => Ok(t.clone()),
             None => {
                 let name =
                     HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidResponseArg(arg.into()))?;
@@ -197,7 +197,7 @@ impl Grammar for EnvoyGrammar {
         let mut i = 0;
 
         while i < input.len() {
-            let mut longest_placeholder: Option<(Token, usize, Option<TokenArgument>)> = None;
+            let mut longest_placeholder: Option<(Token, Category, Option<TokenArgument>, usize)> = None;
             let mut skip = None;
 
             // finst the longest placeholder starting from the current index i
@@ -206,7 +206,7 @@ impl Grammar for EnvoyGrammar {
                 let remainder = &input[i + 1..];
                 if remainder.starts_with('%') {
                     skip = Some(2);
-                } else if let Some((placeholder, placeholder_len, has_arg)) =
+                } else if let Some((placeholder, category, placeholder_len, has_arg)) =
                     ENVOY_PATTERNS.find_longest_prefix(remainder.bytes())
                 {
                     let after_placeholder = &remainder[*placeholder_len..];
@@ -214,17 +214,25 @@ impl Grammar for EnvoyGrammar {
                     if *has_arg {
                         let (arg_value, arg_len) = Self::extract_token_arg(after_placeholder)?;
 
-                        if longest_placeholder.is_none() || *placeholder_len > longest_placeholder.as_ref().unwrap().1 {
+                        if longest_placeholder.is_none() || *placeholder_len > longest_placeholder.as_ref().unwrap().3 {
                             match placeholder {
                                 Token::Request => {
                                     let arg = Self::parse_request(arg_value)?;
-                                    longest_placeholder =
-                                        Some((*placeholder, *placeholder_len, Some(TokenArgument::Request(arg))));
+                                    longest_placeholder = Some((
+                                        *placeholder,
+                                        *category,
+                                        Some(TokenArgument::Request(arg)),
+                                        *placeholder_len,
+                                    ));
                                 },
                                 Token::Response => {
                                     let arg = Self::parse_response(arg_value)?;
-                                    longest_placeholder =
-                                        Some((*placeholder, *placeholder_len, Some(TokenArgument::Response(arg))));
+                                    longest_placeholder = Some((
+                                        *placeholder,
+                                        *category,
+                                        Some(TokenArgument::Response(arg)),
+                                        *placeholder_len,
+                                    ));
                                 },
                                 _ => (),
                             }
@@ -236,7 +244,7 @@ impl Grammar for EnvoyGrammar {
 
                         skip = Some(2 + *placeholder_len + arg_len);
                     } else {
-                        longest_placeholder = Some((*placeholder, *placeholder_len, None));
+                        longest_placeholder = Some((*placeholder, *category, None, *placeholder_len));
                         if !after_placeholder.starts_with('%') {
                             return Err(FormatError::MissingDelimiter(remainder.into()));
                         }
@@ -258,6 +266,7 @@ impl Grammar for EnvoyGrammar {
                 parts.push(Template::Placeholder(
                     // input[i..i + skip.unwrap()].into() <- this is original placeholder
                     placeholder.0.into(),
+                    placeholder.1.into(),
                     placeholder.2.clone(),
                 ));
 
@@ -298,8 +307,10 @@ mod tests {
     #[test]
     fn test_parse_only_placeholders() {
         let input = "%START_TIME%%PROTOCOL%";
-        let expected =
-            vec![Template::Placeholder(Token::StartTime, None), Template::Placeholder(Token::Protocol, None)];
+        let expected = vec![
+            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT, None),
+            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST, None),
+        ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
@@ -309,9 +320,13 @@ mod tests {
         let input = "Start %REQ(:METHOD)% middle %PROTOCOL% end.";
         let expected = vec![
             Template::Literal("Start ".into()),
-            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Method))),
+            Template::Placeholder(
+                Token::Request,
+                Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST,
+                Some(TokenArgument::Request(ReqArg::Method)),
+            ),
             Template::Literal(" middle ".into()),
-            Template::Placeholder(Token::Protocol, None),
+            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST, None),
             Template::Literal(" end.".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
@@ -321,7 +336,10 @@ mod tests {
     #[test]
     fn test_parse_starts_with_placeholder() {
         let input = "%START_TIME% literal after.";
-        let expected = vec![Template::Placeholder(Token::StartTime, None), Template::Literal(" literal after.".into())];
+        let expected = vec![
+            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT, None),
+            Template::Literal(" literal after.".into()),
+        ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
@@ -329,7 +347,10 @@ mod tests {
     #[test]
     fn test_parse_ends_with_placeholder() {
         let input = "Literal before %PROTOCOL%";
-        let expected = vec![Template::Literal("Literal before ".into()), Template::Placeholder(Token::Protocol, None)];
+        let expected = vec![
+            Template::Literal("Literal before ".into()),
+            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST, None),
+        ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
     }
@@ -355,13 +376,21 @@ mod tests {
         let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%""#;
         let expected = vec![
             Template::Literal("[".into()),
-            Template::Placeholder(Token::StartTime, None),
+            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT, None),
             Template::Literal("] \"".into()),
-            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Method))),
+            Template::Placeholder(
+                Token::Request,
+                Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST,
+                Some(TokenArgument::Request(ReqArg::Method)),
+            ),
             Template::Literal(" ".into()),
-            Template::Placeholder(Token::Request, Some(TokenArgument::Request(ReqArg::Path))),
+            Template::Placeholder(
+                Token::Request,
+                Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST,
+                Some(TokenArgument::Request(ReqArg::Path)),
+            ),
             Template::Literal(" ".into()),
-            Template::Placeholder(Token::Protocol, None),
+            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST, None),
             Template::Literal("\"".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
@@ -409,7 +438,7 @@ mod tests {
 
     #[test]
     fn test_parse_error_missing_delimiter_1() {
-        let input = "%REQUEST_DURATION";
+        let input = "%UPSTREAM_HOST";
         let result = EnvoyGrammar::parse(input);
         assert!(matches!(result, Err(FormatError::MissingDelimiter(_))));
     }
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index f69aa69e..7d3d8792 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -8,7 +8,7 @@ use smol_str::SmolStr;
 use std::fmt::{self, Display, Formatter};
 use std::io::Write;
 use thiserror::Error;
-use token::{Token, TokenArgument};
+use token::{Category, Token, TokenArgument};
 
 use crate::grammar::EnvoyGrammar;
 
@@ -33,7 +33,7 @@ pub enum FormatError {
 #[derive(PartialEq, Debug, Clone)]
 pub enum Template {
     Literal(SmolStr),
-    Placeholder(Token, Option<TokenArgument>), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
+    Placeholder(Token, Category, Option<TokenArgument>), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
 }
 
 #[derive(PartialEq, Debug, Clone)]
@@ -49,15 +49,18 @@ impl LogFormatter {
 
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
         let total_keys = C::number_keys();
+        let context_category = C::category();
         let mut eval_tokens = 0;
         for part in &mut self.template {
             if eval_tokens == total_keys {
                 break;
             }
-            if let Template::Placeholder(token, arg) = part {
+            if let Template::Placeholder(token, categories, arg) = part {
                 eval_tokens += 1;
-                if let Some(value) = ctx.eval_part(token, arg) {
-                    *part = Template::Literal(value.into_owned()); // TODO: Reduce memory allocations by grouping consecutive expanded templates
+                if categories.contains(context_category) {
+                    if let Some(value) = ctx.eval_part(token, arg) {
+                        *part = Template::Literal(value.into_owned()); // TODO: Reduce memory allocations by grouping consecutive expanded templates
+                    }
                 }
             }
         }
@@ -70,7 +73,7 @@ impl LogFormatter {
         for part in &self.template {
             total_bytes += match part {
                 Template::Literal(s) => w.write(s.as_bytes())?,
-                Template::Placeholder(_, _) => w.write("UNSUP".as_bytes())?,
+                Template::Placeholder(_, _, _) => w.write("UNSUP".as_bytes())?,
             };
         }
 
@@ -83,7 +86,7 @@ impl Display for LogFormatter {
         for part in &self.template {
             match part {
                 Template::Literal(s) => f.write_str(s.as_ref())?,
-                Template::Placeholder(_, _) => {
+                Template::Placeholder(_, _, _) => {
                     f.write_str("UNSUP")?;
                 },
             }
diff --git a/orion-format/src/token.rs b/orion-format/src/token.rs
index 7133cd29..f087a5f2 100644
--- a/orion-format/src/token.rs
+++ b/orion-format/src/token.rs
@@ -1,5 +1,19 @@
+use bitflags::bitflags;
 use http::HeaderName;
 
+bitflags! {
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct Category: u16 {
+        const INIT_CONTEXT = 1;
+        const FINISH_CONTEXT = 1 << 1;
+        const DOWNSTREAM_REQUEST = 1 << 1;
+        const DOWNSTREAM_RESPONSE = 1 << 2;
+        const UPSTREAM_REQUEST = 1 << 3;
+        const UPSTREAM_RESPONSE = 1 << 4;
+        const ARGUMENT = 1 << 5;
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, Hash, Debug)]
 pub enum Token {
     RequestDuration,

From 1dfc837b515ed6232fb06ac2c0148762780b4d2f Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Wed, 14 May 2025 10:58:03 +0200
Subject: [PATCH 26/64] Improve rfc3339 DateTime format with SmolStrBuilder.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/context.rs | 54 +++++++++++++++++++++++++++++++++----
 1 file changed, 49 insertions(+), 5 deletions(-)

diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 6c915fc4..c1b01a63 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -1,8 +1,8 @@
 use std::time::{Duration, SystemTime};
 
-use chrono::{DateTime, SecondsFormat, Utc};
+use chrono::{DateTime, Datelike, Timelike, Utc};
 use http::{Request, Response, Version};
-use smol_str::{format_smolstr, SmolStr};
+use smol_str::{format_smolstr, SmolStr, SmolStrBuilder};
 
 use crate::smol_cow::SmolCow;
 use crate::token::{Category, ReqArg, RespArg, Token, TokenArgument};
@@ -35,9 +35,8 @@ impl Context for InitContext {
     fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
         match token {
             Token::StartTime => {
-                let datetime_utc: DateTime<Utc> = self.start_time.into();
-                let rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
-                Some(SmolCow::Owned(rfc3339.into()))
+                let rfc3339 = format_system_time(self.start_time).ok()?;
+                Some(SmolCow::Owned(rfc3339))
             },
             _ => None,
         }
@@ -131,3 +130,48 @@ impl<'r, T> Context for DownstreamResponse<'r, T> {
         }
     }
 }
+
+pub fn format_system_time(time: SystemTime) -> std::result::Result<SmolStr, std::fmt::Error> {
+    let datetime: DateTime<Utc> = time.into();
+    let mut builder = SmolStrBuilder::new();
+
+    const TWO_DIGITS: [&str; 100] = [
+        "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17",
+        "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35",
+        "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53",
+        "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71",
+        "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89",
+        "90", "91", "92", "93", "94", "95", "96", "97", "98", "99",
+    ];
+
+    four_digits(&mut builder, datetime.year());
+    builder.push('-');
+    builder.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.month() as usize) });
+    builder.push('-');
+    builder.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.day() as usize) });
+    builder.push('T');
+    builder.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.hour() as usize) });
+    builder.push(':');
+    builder.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.minute() as usize) });
+    builder.push(':');
+    builder.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.second() as usize) });
+    builder.push(':');
+    three_digits(&mut builder, datetime.nanosecond() / 1_000_000);
+
+    Ok(builder.finish())
+}
+
+#[inline(always)]
+fn three_digits(builder: &mut SmolStrBuilder, value: u32) {
+    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 100 % 10) as u8)) as u32) });
+    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 10 % 10) as u8)) as u32) });
+    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value % 10) as u8)) as u32) });
+}
+
+#[inline(always)]
+fn four_digits(builder: &mut SmolStrBuilder, value: i32) {
+    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 1000 % 10) as u8)) as u32) });
+    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 100 % 10) as u8)) as u32) });
+    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 10 % 10) as u8)) as u32) });
+    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value % 10) as u8)) as u32) });
+}

From dd6128e540263416f147a5f946a05fd2d793b9fa Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 16 May 2025 05:48:07 +0200
Subject: [PATCH 27/64] Benchmark tests updated.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 27 ++-------------------------
 1 file changed, 2 insertions(+), 25 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 41bc571a..1cfa887e 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -176,27 +176,9 @@ fn benchmark_log_formatter(c: &mut Criterion) {
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
     let mut sink = std::io::sink();
 
-    c.bench_function("LogFormatter: DownstreamRequest", |b| {
+    c.bench_function("LogFormatter: clone only", |b| {
         b.iter(|| {
-            black_box(fmt.clone().with_context(&DownstreamRequest(&request)));
-        })
-    });
-
-    c.bench_function("LogFormatter: DownstreamResponse", |b| {
-        b.iter(|| {
-            black_box(fmt.clone().with_context(&DownstreamResponse(&response)));
-        })
-    });
-
-    c.bench_function("LogFormatter: InitContext", |b| {
-        b.iter(|| {
-            black_box(fmt.clone().with_context(&start));
-        })
-    });
-
-    c.bench_function("LogFormatter: FinishContext", |b| {
-        b.iter(|| {
-            black_box(fmt.clone().with_context(&end));
+            black_box(fmt.clone());
         })
     });
 
@@ -226,11 +208,6 @@ fn benchmark_log_formatter(c: &mut Criterion) {
     });
 }
 
-fn benchmark_clone_formatter(c: &mut Criterion) {
-    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
-    c.bench_function("Clone formatter", |b| b.iter(|| black_box(fmt.clone())));
-}
-
 fn benchmark_request_parts(c: &mut Criterion) {
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")

From 6dad024b71e963bcf9c2106da710b63b214e0a6c Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 16 May 2025 06:10:35 +0200
Subject: [PATCH 28/64] Refactor token handling to simplify argument structure

- Removed `TokenArgument`, `ReqArg`, and `RespArg` enums.
- Consolidated request and response token variants directly into `Token`.
- Updated `Context` trait and implementations to remove argument handling.
- Simplified `Template::Placeholder` by removing optional argument field.
- Adjusted `LogFormatter` logic to align with new token structure.
- Dismiss `number_keys` method from `Context` trait.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs |  1 -
 orion-format/src/context.rs       | 53 ++++++--------------
 orion-format/src/grammar.rs       | 83 +++++++++++--------------------
 orion-format/src/lib.rs           | 17 +++----
 orion-format/src/token.rs         | 32 ++++--------
 5 files changed, 61 insertions(+), 125 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 1cfa887e..5e865a6a 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -286,7 +286,6 @@ criterion_group!(
     benches,
     benchmark_rust_format,
     benchmark_log_formatter,
-    benchmark_clone_formatter,
     benchmark_request_parts,
     benchmark_small_cow
 );
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index c1b01a63..1c844b4d 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -5,11 +5,10 @@ use http::{Request, Response, Version};
 use smol_str::{format_smolstr, SmolStr, SmolStrBuilder};
 
 use crate::smol_cow::SmolCow;
-use crate::token::{Category, ReqArg, RespArg, Token, TokenArgument};
+use crate::token::{Category, Token};
 
 pub trait Context {
-    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>>;
-    fn number_keys() -> usize;
+    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>>;
     fn category() -> Category;
 }
 
@@ -26,13 +25,10 @@ pub struct FinishContext {
 }
 
 impl Context for InitContext {
-    fn number_keys() -> usize {
-        1
-    }
     fn category() -> Category {
         Category::INIT_CONTEXT
     }
-    fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
+    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>> {
         match token {
             Token::StartTime => {
                 let rfc3339 = format_system_time(self.start_time).ok()?;
@@ -44,13 +40,10 @@ impl Context for InitContext {
 }
 
 impl Context for FinishContext {
-    fn number_keys() -> usize {
-        3
-    }
     fn category() -> Category {
         Category::FINISH_CONTEXT
     }
-    fn eval_part<'a>(&'a self, token: &Token, _arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
+    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>> {
         match token {
             Token::Duration => Some(SmolCow::Owned(format_smolstr!("{}", self.duration.as_millis()))),
             Token::BytesReceived => Some(SmolCow::Owned(format_smolstr!("{}", self.bytes_received))),
@@ -66,34 +59,23 @@ pub struct DownstreamResponse<'a, T>(pub &'a Response<T>);
 pub struct UpstreamResponse<'a, T>(pub &'a Response<T>);
 
 impl<'r, T> Context for DownstreamRequest<'r, T> {
-    fn number_keys() -> usize {
-        6
-    }
     fn category() -> Category {
         Category::DOWNSTREAM_REQUEST
     }
-    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
-        match (token, arg) {
-            (Token::Request, Some(TokenArgument::Request(ReqArg::Path))) => {
-                Some(SmolCow::Borrowed(self.0.uri().path()))
-            },
-            (Token::Request, Some(TokenArgument::Request(ReqArg::Authority))) => {
-                self.0.uri().authority().and_then(|a| Some(SmolCow::Borrowed(a.host())))
-            },
-            (Token::Request, Some(TokenArgument::Request(ReqArg::Method))) => {
-                Some(SmolCow::Borrowed(self.0.method().as_str()))
-            },
-            (Token::Request, Some(TokenArgument::Request(ReqArg::Scheme))) => {
-                self.0.uri().scheme().map(|s| SmolCow::Owned(format_smolstr!("{}", s)))
-            },
-            (Token::Request, Some(TokenArgument::Request(ReqArg::NormalHeader(h)))) => {
+    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>> {
+        match token {
+            Token::RequestPath => Some(SmolCow::Borrowed(self.0.uri().path())),
+            Token::RequestAuthority => self.0.uri().authority().and_then(|a| Some(SmolCow::Borrowed(a.host()))),
+            Token::RequestMethod => Some(SmolCow::Borrowed(self.0.method().as_str())),
+            Token::RequestScheme => self.0.uri().scheme().map(|s| SmolCow::Owned(format_smolstr!("{}", s))),
+            Token::RequestStandard(h) => {
                 let hv = self.0.headers().get(h);
                 match hv {
                     Some(hv) => hv.to_str().ok().map(SmolCow::Borrowed),
                     None => Some(SmolCow::Borrowed("")),
                 }
             },
-            (Token::Protocol, _) => {
+            Token::Protocol => {
                 let ver = match self.0.version() {
                     Version::HTTP_10 => "HTTP/1.0",
                     Version::HTTP_11 => "HTTP/1.1",
@@ -110,16 +92,13 @@ impl<'r, T> Context for DownstreamRequest<'r, T> {
 }
 
 impl<'r, T> Context for DownstreamResponse<'r, T> {
-    fn number_keys() -> usize {
-        2
-    }
     fn category() -> Category {
         Category::DOWNSTREAM_RESPONSE
     }
-    fn eval_part<'a>(&'a self, token: &Token, arg: &Option<TokenArgument>) -> Option<SmolCow<'a>> {
-        match (token, arg) {
-            (Token::ResponseCode, _) => Some(SmolCow::Owned(SmolStr::new_inline(self.0.status().as_str()))),
-            (Token::Response, Some(TokenArgument::Response(RespArg::NormalHeader(h)))) => {
+    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>> {
+        match token {
+            Token::ResponseCode => Some(SmolCow::Owned(SmolStr::new_inline(self.0.status().as_str()))),
+            Token::ResponseStandard(h) => {
                 let hv = self.0.headers().get(h.as_str());
                 match hv {
                     Some(hv) => hv.to_str().ok().map(SmolCow::Borrowed),
diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index 7ade408a..eb28906c 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -1,4 +1,4 @@
-use crate::token::{Category, ReqArg, RespArg, Token, TokenArgument};
+use crate::token::{Category, Token};
 use crate::{FormatError, Grammar, Template};
 use http::HeaderName;
 use lazy_static::lazy_static;
@@ -14,16 +14,16 @@ macro_rules! trie_mapstr {
 }
 
 lazy_static! {
-    static ref ENVOY_REQ_ARGS: Trie<u8, (ReqArg, Category, usize, bool)> = {
+    static ref ENVOY_REQ_ARGS: Trie<u8, (Token, Category, usize, bool)> = {
         let mut trie = Trie::new();
-        trie_mapstr!(trie, ":SCHEME",ReqArg::Scheme, Category::ARGUMENT);
-        trie_mapstr!(trie, ":METHOD",ReqArg::Method, Category::ARGUMENT);
-        trie_mapstr!(trie, ":PATH", ReqArg::Path, Category::ARGUMENT);
-        trie_mapstr!(trie, ":AUTHORITY",ReqArg::Authority, Category::ARGUMENT);
+        trie_mapstr!(trie, ":SCHEME",Token::RequestScheme, Category::ARGUMENT);
+        trie_mapstr!(trie, ":METHOD",Token::RequestMethod, Category::ARGUMENT);
+        trie_mapstr!(trie, ":PATH", Token::RequestPath, Category::ARGUMENT);
+        trie_mapstr!(trie, ":AUTHORITY", Token::RequestAuthority, Category::ARGUMENT);
         trie
     };
 
-    static ref ENVOY_RESP_ARGS: Trie<u8, (RespArg, Category, usize, bool)> = {
+    static ref ENVOY_RESP_ARGS: Trie<u8, (Token, Category, usize, bool)> = {
         let trie = Trie::new();
         trie
     };
@@ -153,24 +153,24 @@ lazy_static! {
 pub struct EnvoyGrammar;
 
 impl EnvoyGrammar {
-    fn parse_request(arg: &str) -> Result<ReqArg, FormatError> {
+    fn parse_request(arg: &str) -> Result<Token, FormatError> {
         match ENVOY_REQ_ARGS.find_longest_prefix(arg.bytes()) {
             Some((t, _, _, _)) => Ok(t.clone()),
             None => {
                 let name =
                     HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidRequestArg(arg.into()))?;
-                Ok(ReqArg::NormalHeader(name))
+                Ok(Token::RequestStandard(name))
             },
         }
     }
 
-    fn parse_response(arg: &str) -> Result<RespArg, FormatError> {
+    fn parse_response(arg: &str) -> Result<Token, FormatError> {
         match ENVOY_RESP_ARGS.find_longest_prefix(arg.bytes()) {
             Some((t, _, _, _)) => Ok(t.clone()),
             None => {
                 let name =
                     HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidResponseArg(arg.into()))?;
-                Ok(RespArg::NormalHeader(name))
+                Ok(Token::ResponseStandard(name))
             },
         }
     }
@@ -197,7 +197,7 @@ impl Grammar for EnvoyGrammar {
         let mut i = 0;
 
         while i < input.len() {
-            let mut longest_placeholder: Option<(Token, Category, Option<TokenArgument>, usize)> = None;
+            let mut longest_placeholder: Option<(Token, Category, usize)> = None;
             let mut skip = None;
 
             // finst the longest placeholder starting from the current index i
@@ -214,25 +214,15 @@ impl Grammar for EnvoyGrammar {
                     if *has_arg {
                         let (arg_value, arg_len) = Self::extract_token_arg(after_placeholder)?;
 
-                        if longest_placeholder.is_none() || *placeholder_len > longest_placeholder.as_ref().unwrap().3 {
+                        if longest_placeholder.is_none() || *placeholder_len > longest_placeholder.as_ref().unwrap().2 {
                             match placeholder {
                                 Token::Request => {
-                                    let arg = Self::parse_request(arg_value)?;
-                                    longest_placeholder = Some((
-                                        *placeholder,
-                                        *category,
-                                        Some(TokenArgument::Request(arg)),
-                                        *placeholder_len,
-                                    ));
+                                    let token = Self::parse_request(arg_value)?;
+                                    longest_placeholder = Some((token, *category, *placeholder_len));
                                 },
                                 Token::Response => {
-                                    let arg = Self::parse_response(arg_value)?;
-                                    longest_placeholder = Some((
-                                        *placeholder,
-                                        *category,
-                                        Some(TokenArgument::Response(arg)),
-                                        *placeholder_len,
-                                    ));
+                                    let token = Self::parse_response(arg_value)?;
+                                    longest_placeholder = Some((token, *category, *placeholder_len));
                                 },
                                 _ => (),
                             }
@@ -244,7 +234,7 @@ impl Grammar for EnvoyGrammar {
 
                         skip = Some(2 + *placeholder_len + arg_len);
                     } else {
-                        longest_placeholder = Some((*placeholder, *category, None, *placeholder_len));
+                        longest_placeholder = Some((placeholder.clone(), *category, *placeholder_len));
                         if !after_placeholder.starts_with('%') {
                             return Err(FormatError::MissingDelimiter(remainder.into()));
                         }
@@ -265,9 +255,8 @@ impl Grammar for EnvoyGrammar {
                 // Add this placeholder.
                 parts.push(Template::Placeholder(
                     // input[i..i + skip.unwrap()].into() <- this is original placeholder
-                    placeholder.0.into(),
-                    placeholder.1.into(),
-                    placeholder.2.clone(),
+                    placeholder.0.clone(),
+                    placeholder.1,
                 ));
 
                 // advnace the index beyond the current placeholder and possibly its argument.
@@ -308,8 +297,8 @@ mod tests {
     fn test_parse_only_placeholders() {
         let input = "%START_TIME%%PROTOCOL%";
         let expected = vec![
-            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT, None),
-            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST, None),
+            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT),
+            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
@@ -320,13 +309,9 @@ mod tests {
         let input = "Start %REQ(:METHOD)% middle %PROTOCOL% end.";
         let expected = vec![
             Template::Literal("Start ".into()),
-            Template::Placeholder(
-                Token::Request,
-                Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST,
-                Some(TokenArgument::Request(ReqArg::Method)),
-            ),
+            Template::Placeholder(Token::RequestMethod, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST),
             Template::Literal(" middle ".into()),
-            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST, None),
+            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
             Template::Literal(" end.".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
@@ -337,7 +322,7 @@ mod tests {
     fn test_parse_starts_with_placeholder() {
         let input = "%START_TIME% literal after.";
         let expected = vec![
-            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT, None),
+            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT),
             Template::Literal(" literal after.".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
@@ -349,7 +334,7 @@ mod tests {
         let input = "Literal before %PROTOCOL%";
         let expected = vec![
             Template::Literal("Literal before ".into()),
-            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST, None),
+            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
@@ -376,21 +361,13 @@ mod tests {
         let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%""#;
         let expected = vec![
             Template::Literal("[".into()),
-            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT, None),
+            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT),
             Template::Literal("] \"".into()),
-            Template::Placeholder(
-                Token::Request,
-                Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST,
-                Some(TokenArgument::Request(ReqArg::Method)),
-            ),
+            Template::Placeholder(Token::RequestMethod, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST),
             Template::Literal(" ".into()),
-            Template::Placeholder(
-                Token::Request,
-                Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST,
-                Some(TokenArgument::Request(ReqArg::Path)),
-            ),
+            Template::Placeholder(Token::RequestPath, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST),
             Template::Literal(" ".into()),
-            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST, None),
+            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
             Template::Literal("\"".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 7d3d8792..3eda7766 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -8,7 +8,7 @@ use smol_str::SmolStr;
 use std::fmt::{self, Display, Formatter};
 use std::io::Write;
 use thiserror::Error;
-use token::{Category, Token, TokenArgument};
+use token::{Category, Token};
 
 use crate::grammar::EnvoyGrammar;
 
@@ -33,7 +33,7 @@ pub enum FormatError {
 #[derive(PartialEq, Debug, Clone)]
 pub enum Template {
     Literal(SmolStr),
-    Placeholder(Token, Category, Option<TokenArgument>), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
+    Placeholder(Token, Category), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
 }
 
 #[derive(PartialEq, Debug, Clone)]
@@ -48,17 +48,12 @@ impl LogFormatter {
     }
 
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
-        let total_keys = C::number_keys();
         let context_category = C::category();
         let mut eval_tokens = 0;
         for part in &mut self.template {
-            if eval_tokens == total_keys {
-                break;
-            }
-            if let Template::Placeholder(token, categories, arg) = part {
-                eval_tokens += 1;
+            if let Template::Placeholder(token, categories) = part {
                 if categories.contains(context_category) {
-                    if let Some(value) = ctx.eval_part(token, arg) {
+                    if let Some(value) = ctx.eval_part(token) {
                         *part = Template::Literal(value.into_owned()); // TODO: Reduce memory allocations by grouping consecutive expanded templates
                     }
                 }
@@ -73,7 +68,7 @@ impl LogFormatter {
         for part in &self.template {
             total_bytes += match part {
                 Template::Literal(s) => w.write(s.as_bytes())?,
-                Template::Placeholder(_, _, _) => w.write("UNSUP".as_bytes())?,
+                Template::Placeholder(_, _) => w.write("UNSUP".as_bytes())?,
             };
         }
 
@@ -86,7 +81,7 @@ impl Display for LogFormatter {
         for part in &self.template {
             match part {
                 Template::Literal(s) => f.write_str(s.as_ref())?,
-                Template::Placeholder(_, _, _) => {
+                Template::Placeholder(_, _) => {
                     f.write_str("UNSUP")?;
                 },
             }
diff --git a/orion-format/src/token.rs b/orion-format/src/token.rs
index f087a5f2..e419434a 100644
--- a/orion-format/src/token.rs
+++ b/orion-format/src/token.rs
@@ -14,7 +14,7 @@ bitflags! {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Hash, Debug)]
+#[derive(Clone, PartialEq, Hash, Debug)]
 pub enum Token {
     RequestDuration,
     RequestTxDuration,
@@ -130,26 +130,12 @@ pub enum Token {
     UpstreamPeerCertVEnd,
     Environment,
     UpstreamConnectionPoolReadyDuration,
-    Request,
-    Response,
-}
-
-#[derive(Debug, Clone, PartialEq, Hash)]
-pub enum TokenArgument {
-    Request(ReqArg),
-    Response(RespArg),
-}
-
-#[derive(Clone, PartialEq, Hash, Debug)]
-pub enum ReqArg {
-    Scheme,
-    Method,
-    Path,
-    Authority,
-    NormalHeader(HeaderName),
-}
-
-#[derive(Clone, PartialEq, Hash, Debug)]
-pub enum RespArg {
-    NormalHeader(HeaderName),
+    Request, // placeholder
+    RequestScheme,
+    RequestMethod,
+    RequestPath,
+    RequestAuthority,
+    RequestStandard(HeaderName),
+    Response, // placeholder
+    ResponseStandard(HeaderName),
 }

From 8482fa15b13bf368cbee3b6ce51a14f28bd84740 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 16 May 2025 08:24:29 +0200
Subject: [PATCH 29/64] Code improvements.

- Replace SmolCow with SmolStr for context evaluation in `eval_part`.
- Simplify handling of single-character literals in grammar parsing.
- Introduce `Smol` enum to unify handling of `SmolStr` and `char` in templates.
- Update `LogFormatter` to precompute static template parts for efficiency.
- Adjust `write_to` and `Display` implementations to use precomputed format.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs |  9 +---
 orion-format/src/context.rs       | 83 +++++++++++++++++++++----------
 orion-format/src/grammar.rs       | 23 ++++++---
 orion-format/src/lib.rs           | 64 ++++++++++++++++--------
 4 files changed, 117 insertions(+), 62 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 5e865a6a..495305fd 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -282,11 +282,6 @@ fn benchmark_small_cow(c: &mut Criterion) {
     });
 }
 
-criterion_group!(
-    benches,
-    benchmark_rust_format,
-    benchmark_log_formatter,
-    benchmark_request_parts,
-    benchmark_small_cow
-);
+criterion_group!(benches, benchmark_rust_format, benchmark_log_formatter, benchmark_request_parts, benchmark_small_cow);
+
 criterion_main!(benches);
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 1c844b4d..0eb94c56 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -4,11 +4,13 @@ use chrono::{DateTime, Datelike, Timelike, Utc};
 use http::{Request, Response, Version};
 use smol_str::{format_smolstr, SmolStr, SmolStrBuilder};
 
-use crate::smol_cow::SmolCow;
-use crate::token::{Category, Token};
+use crate::{
+    token::{Category, Token},
+    Smol,
+};
 
 pub trait Context {
-    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>>;
+    fn eval_part<'a>(&'a self, token: &Token) -> Smol;
     fn category() -> Category;
 }
 
@@ -28,13 +30,16 @@ impl Context for InitContext {
     fn category() -> Category {
         Category::INIT_CONTEXT
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>> {
+    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
         match token {
             Token::StartTime => {
-                let rfc3339 = format_system_time(self.start_time).ok()?;
-                Some(SmolCow::Owned(rfc3339))
+                if let Some(s) = format_system_time(self.start_time).ok() {
+                    Smol::Str(s)
+                } else {
+                    Smol::None
+                }
             },
-            _ => None,
+            _ => Smol::None,
         }
     }
 }
@@ -43,12 +48,12 @@ impl Context for FinishContext {
     fn category() -> Category {
         Category::FINISH_CONTEXT
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>> {
+    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
         match token {
-            Token::Duration => Some(SmolCow::Owned(format_smolstr!("{}", self.duration.as_millis()))),
-            Token::BytesReceived => Some(SmolCow::Owned(format_smolstr!("{}", self.bytes_received))),
-            Token::BytesSent => Some(SmolCow::Owned(format_smolstr!("{}", self.bytes_sent))),
-            _ => None,
+            Token::Duration => Smol::Str(format_smolstr!("{}", self.duration.as_millis())),
+            Token::BytesReceived => Smol::Str(format_smolstr!("{}", self.bytes_received)),
+            Token::BytesSent => Smol::Str(format_smolstr!("{}", self.bytes_sent)),
+            _ => Smol::None,
         }
     }
 }
@@ -62,17 +67,36 @@ impl<'r, T> Context for DownstreamRequest<'r, T> {
     fn category() -> Category {
         Category::DOWNSTREAM_REQUEST
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>> {
+    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
         match token {
-            Token::RequestPath => Some(SmolCow::Borrowed(self.0.uri().path())),
-            Token::RequestAuthority => self.0.uri().authority().and_then(|a| Some(SmolCow::Borrowed(a.host()))),
-            Token::RequestMethod => Some(SmolCow::Borrowed(self.0.method().as_str())),
-            Token::RequestScheme => self.0.uri().scheme().map(|s| SmolCow::Owned(format_smolstr!("{}", s))),
+            Token::RequestPath => Smol::Str(SmolStr::new(self.0.uri().path())),
+            Token::RequestAuthority => {
+                if let Some(a) = self.0.uri().authority() {
+                    Smol::Str(SmolStr::new(a.host()))
+                } else {
+                    Smol::None
+                }
+            },
+            Token::RequestMethod => Smol::Str(SmolStr::new(self.0.method().as_str())),
+            Token::RequestScheme => {
+                if let Some(s) = self.0.uri().scheme() {
+                    Smol::Str(format_smolstr!("{}", s))
+                } else {
+                    Smol::None
+                }
+            },
+
             Token::RequestStandard(h) => {
                 let hv = self.0.headers().get(h);
                 match hv {
-                    Some(hv) => hv.to_str().ok().map(SmolCow::Borrowed),
-                    None => Some(SmolCow::Borrowed("")),
+                    Some(hv) => {
+                        if let Some(s) = hv.to_str().ok() {
+                            Smol::Str(SmolStr::new(s))
+                        } else {
+                            Smol::None
+                        }
+                    },
+                    None => Smol::Str(SmolStr::new_static("")),
                 }
             },
             Token::Protocol => {
@@ -84,9 +108,9 @@ impl<'r, T> Context for DownstreamRequest<'r, T> {
                     _ => "HTTP/UNKNOWN",
                 };
 
-                Some(SmolCow::Borrowed(ver))
+                Smol::Str(SmolStr::new_static(ver))
             },
-            _ => None,
+            _ => Smol::None,
         }
     }
 }
@@ -95,17 +119,24 @@ impl<'r, T> Context for DownstreamResponse<'r, T> {
     fn category() -> Category {
         Category::DOWNSTREAM_RESPONSE
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> Option<SmolCow<'a>> {
+    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
         match token {
-            Token::ResponseCode => Some(SmolCow::Owned(SmolStr::new_inline(self.0.status().as_str()))),
+            Token::ResponseCode => Smol::Str(SmolStr::new_inline(self.0.status().as_str())),
             Token::ResponseStandard(h) => {
                 let hv = self.0.headers().get(h.as_str());
                 match hv {
-                    Some(hv) => hv.to_str().ok().map(SmolCow::Borrowed),
-                    None => Some(SmolCow::Borrowed("")),
+                    Some(hv) => {
+                        if let Some(s) = hv.to_str().ok() {
+                            Smol::Str(SmolStr::new(s))
+                        } else {
+                            Smol::None
+                        }
+                    },
+
+                    None => Smol::Str(SmolStr::new_static("")),
                 }
             },
-            _ => None,
+            _ => Smol::None,
         }
     }
 }
diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index eb28906c..3a736c83 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -249,7 +249,11 @@ impl Grammar for EnvoyGrammar {
                 // placeholder found
                 if i > literal_start {
                     let literal_text = &input[literal_start..i];
-                    parts.push(Template::Literal(literal_text.into()));
+                    if literal_text.chars().count() == 1 {
+                        parts.push(Template::Char(literal_text.chars().next().unwrap()));
+                    } else {
+                        parts.push(Template::Literal(literal_text.into()));
+                    }
                 }
 
                 // Add this placeholder.
@@ -271,9 +275,12 @@ impl Grammar for EnvoyGrammar {
 
         // if there's some text remaning, it's a literal
         if i > literal_start {
-            let literal_text = &input[literal_start..i];
-
-            parts.push(Template::Literal(literal_text.replace("%%", "%").into()));
+            let literal_text = &input[literal_start..i].replace("%%", "%");
+            if literal_text.chars().count() == 1 {
+                parts.push(Template::Char(literal_text.chars().next().unwrap()));
+            } else {
+                parts.push(Template::Literal(literal_text.into()));
+            }
         }
 
         Ok(parts)
@@ -360,15 +367,15 @@ mod tests {
     fn test_parse_complex_envoy_string() {
         let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%""#;
         let expected = vec![
-            Template::Literal("[".into()),
+            Template::Char('['),
             Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT),
             Template::Literal("] \"".into()),
             Template::Placeholder(Token::RequestMethod, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST),
-            Template::Literal(" ".into()),
+            Template::Char(' '),
             Template::Placeholder(Token::RequestPath, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST),
-            Template::Literal(" ".into()),
+            Template::Char(' '),
             Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
-            Template::Literal("\"".into()),
+            Template::Char('"'),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 3eda7766..a1486739 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -5,8 +5,9 @@ pub mod token;
 
 use context::Context;
 use smol_str::SmolStr;
-use std::fmt::{self, Display, Formatter};
-use std::io::Write;
+use std::fmt::{self, Display, Formatter, Write};
+use std::io::Write as IoWrite;
+use std::sync::Arc;
 use thiserror::Error;
 use token::{Category, Token};
 
@@ -32,30 +33,46 @@ pub enum FormatError {
 
 #[derive(PartialEq, Debug, Clone)]
 pub enum Template {
+    Char(char),
     Literal(SmolStr),
     Placeholder(Token, Category), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
 }
 
+#[derive(PartialEq, Debug, Clone)]
+pub enum Smol {
+    Str(SmolStr),
+    Char(char),
+    None,
+}
+
 #[derive(PartialEq, Debug, Clone)]
 pub struct LogFormatter {
-    template: Vec<Template>,
+    pub template: Arc<Vec<Template>>,
+    pub format: Vec<Smol>,
 }
 
 impl LogFormatter {
     pub fn try_new(input: &str) -> Result<LogFormatter, FormatError> {
         let template = EnvoyGrammar::parse(input)?;
-        Ok(LogFormatter { template })
+        let mut format: Vec<Smol> = Vec::with_capacity(template.len());
+
+        for t in template.iter() {
+            match t {
+                Template::Char(c) => format.push(Smol::Char(*c)),
+                Template::Literal(smol_str) => format.push(Smol::Str(smol_str.clone())),
+                _ => format.push(Smol::None),
+            }
+        }
+
+        Ok(LogFormatter { template: Arc::new(template), format })
     }
 
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
         let context_category = C::category();
-        let mut eval_tokens = 0;
-        for part in &mut self.template {
+        for (part, out) in self.template.iter().zip(&mut self.format.iter_mut()) {
             if let Template::Placeholder(token, categories) = part {
                 if categories.contains(context_category) {
-                    if let Some(value) = ctx.eval_part(token) {
-                        *part = Template::Literal(value.into_owned()); // TODO: Reduce memory allocations by grouping consecutive expanded templates
-                    }
+                    *out = ctx.eval_part(token);
                 }
             }
         }
@@ -63,12 +80,17 @@ impl LogFormatter {
         self
     }
 
-    pub fn write_to<W: Write>(&self, w: &mut W) -> std::io::Result<usize> {
+    pub fn write_to<W: std::io::Write>(&self, w: &mut W) -> std::io::Result<usize> {
         let mut total_bytes = 0;
-        for part in &self.template {
-            total_bytes += match part {
-                Template::Literal(s) => w.write(s.as_bytes())?,
-                Template::Placeholder(_, _) => w.write("UNSUP".as_bytes())?,
+        for (part, out) in self.template.iter().zip(self.format.iter()) {
+            total_bytes += match out {
+                Smol::Str(s) => IoWrite::write(w, s.as_bytes())?,
+                Smol::Char(c) => {
+                    let mut buf = [0u8; 4];
+                    let bytes = c.encode_utf8(&mut buf).as_bytes();
+                    IoWrite::write(w, bytes)?
+                },
+                _ => IoWrite::write(w, format!("%{:?}%", part).as_bytes())?,
             };
         }
 
@@ -78,13 +100,12 @@ impl LogFormatter {
 
 impl Display for LogFormatter {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        for part in &self.template {
-            match part {
-                Template::Literal(s) => f.write_str(s.as_ref())?,
-                Template::Placeholder(_, _) => {
-                    f.write_str("UNSUP")?;
-                },
-            }
+        for (part, out) in self.template.iter().zip(self.format.iter()) {
+            match out {
+                Smol::Str(s) => f.write_str(s.as_ref())?,
+                Smol::Char(c) => f.write_char(*c)?,
+                _ => f.write_str(&format!("%{:?}%", part))?,
+            };
         }
         Ok(())
     }
@@ -127,6 +148,7 @@ mod tests {
     fn test_request_method() {
         let req = build_request();
         let mut formatter = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
+        println!("FORMATTER: {:?}", formatter);
         let expected = "GET";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);

From 2a5e6dee641650602eab66ec6673eb6b9c8835b8 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 16 May 2025 08:55:54 +0200
Subject: [PATCH 30/64] Refactor `eval_format` to use mutable `LogFormatter`

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 44 ++++++++++++++-----------------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 495305fd..39784a0d 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -16,7 +16,7 @@ static ALLOC: dhat::Alloc = dhat::Alloc;
 const DEF_FMT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
 
 #[inline]
-fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, mut fmt: LogFormatter)
+fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter)
 where
     C1: Context,
     C2: Context,
@@ -184,28 +184,39 @@ fn benchmark_log_formatter(c: &mut Criterion) {
 
     c.bench_function("LogFromatter (full)", |b| {
         b.iter(|| {
+            let mut fmt = fmt.clone();
             black_box(eval_format(
                 &DownstreamRequest(&request),
                 &DownstreamResponse(&response),
                 &start,
                 &end,
-                fmt.clone(),
+                &mut fmt,
             ));
         })
     });
 
     c.bench_function("LogFormatter (full) + write", |b| {
         b.iter(|| {
+            let mut fmt = fmt.clone();
             black_box(eval_format(
                 &DownstreamRequest(&request),
                 &DownstreamResponse(&response),
                 &start,
                 &end,
-                fmt.clone(),
+                &mut fmt,
             ));
             _ = black_box(|| fmt.write_to(&mut sink));
         })
     });
+
+    let mut formatted = fmt.clone();
+    eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut formatted);
+
+    c.bench_function("LogFormatter: write only", |b| {
+        b.iter(|| {
+            _ = black_box(|| formatted.write_to(&mut sink));
+        })
+    });
 }
 
 fn benchmark_request_parts(c: &mut Criterion) {
@@ -222,39 +233,24 @@ fn benchmark_request_parts(c: &mut Criterion) {
     let fmt = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
     c.bench_function("REQ(:PATH)", |b| {
         b.iter(|| {
-            black_box(eval_format(
-                &DownstreamRequest(&request),
-                &DownstreamResponse(&response),
-                &start,
-                &end,
-                fmt.clone(),
-            ))
+            let mut fmt = fmt.clone();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt))
         })
     });
 
     let fmt = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
     c.bench_function("REQ(:METHOD)", |b| {
         b.iter(|| {
-            black_box(eval_format(
-                &DownstreamRequest(&request),
-                &DownstreamResponse(&response),
-                &start,
-                &end,
-                fmt.clone(),
-            ))
+            let mut fmt = fmt.clone();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt))
         })
     });
 
     let fmt = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
     c.bench_function("REQ(USER-AGENT)", |b| {
         b.iter(|| {
-            black_box(eval_format(
-                &DownstreamRequest(&request),
-                &DownstreamResponse(&response),
-                &start,
-                &end,
-                fmt.clone(),
-            ))
+            let mut fmt = fmt.clone();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt))
         })
     });
 }

From 96a3d8d4375d4c7b629240f51ac75bb9f4d319af Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 16 May 2025 09:19:13 +0200
Subject: [PATCH 31/64] Add format-test binary for benchmarking log formatting

Includes a new binary `format-test` to evaluate log formatting
performance. Updates Cargo.toml to register the binary and disables
incremental compilation and rpath.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml             |  8 +++--
 orion-format/src/bin/format-test.rs | 52 +++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 2 deletions(-)
 create mode 100644 orion-format/src/bin/format-test.rs

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index f1c5f7d9..04fc3989 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -30,9 +30,13 @@ strip = "debuginfo"
 debug-assertions = false
 overflow-checks = false
 panic = 'unwind'
-#incremental = false
-#rpath = false
+incremental = false
+rpath = false
 
 [[bench]]
 name = "benchmark"
 harness = false
+
+[[bin]]
+name = "format-test"
+path = "src/bin/format-test.rs"
diff --git a/orion-format/src/bin/format-test.rs b/orion-format/src/bin/format-test.rs
new file mode 100644
index 00000000..24c89a6f
--- /dev/null
+++ b/orion-format/src/bin/format-test.rs
@@ -0,0 +1,52 @@
+use criterion::black_box;
+use http::{Request, Response, StatusCode};
+use orion_format::{
+    context::{Context, DownstreamRequest, DownstreamResponse, FinishContext, InitContext},
+    LogFormatter,
+};
+use std::time::{Duration, Instant};
+
+const DEF_FMT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+
+#[inline]
+fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter)
+where
+    C1: Context,
+    C2: Context,
+    C3: Context,
+    C4: Context,
+{
+    fmt.with_context(req);
+    fmt.with_context(resp);
+    fmt.with_context(start);
+    fmt.with_context(end);
+}
+
+const TOTAL: u64 = 20_000_000;
+
+fn main() {
+    let request = Request::builder()
+        .uri("https://www.rust-lang.org/hello")
+        .header("User-Agent", "my-awesome-agent/1.0")
+        .body(())
+        .unwrap();
+
+    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let start = InitContext { start_time: std::time::SystemTime::now() };
+    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+
+    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
+    let mut sink = std::io::sink();
+
+    let now = Instant::now();
+
+    for _ in 0..TOTAL {
+        let mut fmt_ = black_box(fmt.clone());
+        black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt_));
+        _ = black_box(|| fmt_.write_to(&mut sink));
+    }
+
+    let dur = now.elapsed();
+
+    println!("LogFormat: {:.2} msg/sec", TOTAL as f64 / dur.as_secs_f64());
+}

From d4ace4cdc83d04eac336466e3de47e992589fa1a Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 16 May 2025 11:06:42 +0200
Subject: [PATCH 32/64] Use itoa for integer formatting in context evaluation

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml     |  1 +
 orion-format/src/context.rs | 19 ++++++++++++++-----
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index 04fc3989..cc00e0b9 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -17,6 +17,7 @@ smol_str = "0.3.2"
 chrono = "0.4.40"
 dhat = "0.3.3"
 bitflags = "2.9.0"
+itoa = "1.0.15"
 
 [features]
 dhat-heap = []
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 0eb94c56..332f73a6 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -2,7 +2,7 @@ use std::time::{Duration, SystemTime};
 
 use chrono::{DateTime, Datelike, Timelike, Utc};
 use http::{Request, Response, Version};
-use smol_str::{format_smolstr, SmolStr, SmolStrBuilder};
+use smol_str::{SmolStr, SmolStrBuilder};
 
 use crate::{
     token::{Category, Token},
@@ -50,9 +50,18 @@ impl Context for FinishContext {
     }
     fn eval_part<'a>(&'a self, token: &Token) -> Smol {
         match token {
-            Token::Duration => Smol::Str(format_smolstr!("{}", self.duration.as_millis())),
-            Token::BytesReceived => Smol::Str(format_smolstr!("{}", self.bytes_received)),
-            Token::BytesSent => Smol::Str(format_smolstr!("{}", self.bytes_sent)),
+            Token::Duration => {
+                let mut buffer = itoa::Buffer::new();
+                Smol::Str(SmolStr::new(buffer.format(self.duration.as_millis())))
+            },
+            Token::BytesReceived => {
+                let mut buffer = itoa::Buffer::new();
+                Smol::Str(SmolStr::new(buffer.format(self.bytes_received)))
+            },
+            Token::BytesSent => {
+                let mut buffer = itoa::Buffer::new();
+                Smol::Str(SmolStr::new(buffer.format(self.bytes_sent)))
+            },
             _ => Smol::None,
         }
     }
@@ -80,7 +89,7 @@ impl<'r, T> Context for DownstreamRequest<'r, T> {
             Token::RequestMethod => Smol::Str(SmolStr::new(self.0.method().as_str())),
             Token::RequestScheme => {
                 if let Some(s) = self.0.uri().scheme() {
-                    Smol::Str(format_smolstr!("{}", s))
+                    Smol::Str(SmolStr::new(s.as_str()))
                 } else {
                     Smol::None
                 }

From d16ed5af554caa944b6a49457e1350aea12c1b95 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 16 May 2025 11:42:21 +0200
Subject: [PATCH 33/64] Refactor `format_system_time` to simplify and remove
 helpers

- Removed `three_digits` and `four_digits` helper functions.
- Replaced manual digit formatting with `itoa::Buffer`.
- Updated `Token::StartTime` match arm for cleaner handling.
- Removed unused `serde_json` dependency from `Cargo.toml`.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/context.rs | 32 ++++++--------------------------
 1 file changed, 6 insertions(+), 26 deletions(-)

diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 332f73a6..4c38dbd0 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -32,13 +32,7 @@ impl Context for InitContext {
     }
     fn eval_part<'a>(&'a self, token: &Token) -> Smol {
         match token {
-            Token::StartTime => {
-                if let Some(s) = format_system_time(self.start_time).ok() {
-                    Smol::Str(s)
-                } else {
-                    Smol::None
-                }
-            },
+            Token::StartTime => Smol::Str(format_system_time(self.start_time)),
             _ => Smol::None,
         }
     }
@@ -150,9 +144,10 @@ impl<'r, T> Context for DownstreamResponse<'r, T> {
     }
 }
 
-pub fn format_system_time(time: SystemTime) -> std::result::Result<SmolStr, std::fmt::Error> {
+pub fn format_system_time(time: SystemTime) -> SmolStr {
     let datetime: DateTime<Utc> = time.into();
     let mut builder = SmolStrBuilder::new();
+    let mut buffer = itoa::Buffer::new();
 
     const TWO_DIGITS: [&str; 100] = [
         "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17",
@@ -163,7 +158,7 @@ pub fn format_system_time(time: SystemTime) -> std::result::Result<SmolStr, std:
         "90", "91", "92", "93", "94", "95", "96", "97", "98", "99",
     ];
 
-    four_digits(&mut builder, datetime.year());
+    builder.push_str(buffer.format(datetime.year()));
     builder.push('-');
     builder.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.month() as usize) });
     builder.push('-');
@@ -175,22 +170,7 @@ pub fn format_system_time(time: SystemTime) -> std::result::Result<SmolStr, std:
     builder.push(':');
     builder.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.second() as usize) });
     builder.push(':');
-    three_digits(&mut builder, datetime.nanosecond() / 1_000_000);
-
-    Ok(builder.finish())
-}
-
-#[inline(always)]
-fn three_digits(builder: &mut SmolStrBuilder, value: u32) {
-    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 100 % 10) as u8)) as u32) });
-    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 10 % 10) as u8)) as u32) });
-    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value % 10) as u8)) as u32) });
-}
+    builder.push_str(buffer.format(datetime.nanosecond() / 1_000_000));
 
-#[inline(always)]
-fn four_digits(builder: &mut SmolStrBuilder, value: i32) {
-    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 1000 % 10) as u8)) as u32) });
-    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 100 % 10) as u8)) as u32) });
-    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value / 10 % 10) as u8)) as u32) });
-    builder.push(unsafe { std::char::from_u32_unchecked((b'0' + ((value % 10) as u8)) as u32) });
+    builder.finish()
 }

From e0a29139ebcdf55db64c9a3ba8961e4163cce35d Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 16 May 2025 15:07:40 +0200
Subject: [PATCH 34/64] Add upstream context and response flags to log
 formatting

- Introduced `UpstreamContext` for handling upstream host tokens.
- Added `response_flags` to `FinishContext` for enhanced logging.
- Removed unused `smol_cow` module and related benchmarks.
- Updated tests and benchmarks to reflect new context and fields.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 Cargo.toml                          |  3 ++
 orion-format/benches/benchmark.rs   | 48 ++++++++++++-----------------
 orion-format/src/bin/format-test.rs | 13 ++++++--
 orion-format/src/context.rs         | 42 +++++++++++++++++++------
 orion-format/src/grammar.rs         |  2 +-
 orion-format/src/lib.rs             |  5 +--
 orion-format/src/token.rs           | 12 +++++---
 7 files changed, 76 insertions(+), 49 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 75902421..12fd0f4c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -75,6 +75,9 @@ strip = false
 debug = 1
 inherits = "release"
 
+[profile.bench]
+inherits = "release"
+
 [workspace.lints.clippy]
 pedantic = { level = "warn", priority = -1 }
 disallowed-methods      = "deny"
diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 39784a0d..d0405010 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -3,10 +3,8 @@ use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use http::{HeaderMap, HeaderValue, Request, Response, StatusCode, Version};
 use orion_format::{
     context::{Context, DownstreamRequest, DownstreamResponse, FinishContext, InitContext},
-    smol_cow::SmolCow,
     LogFormatter,
 };
-use smol_str::SmolStr;
 use std::time::Duration;
 
 #[cfg(feature = "dhat-heap")]
@@ -43,7 +41,12 @@ fn benchmark_rust_format(c: &mut Criterion) {
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
     let start = InitContext { start_time: std::time::SystemTime::now() };
-    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    let end = FinishContext {
+        duration: Duration::from_millis(100),
+        bytes_received: 128,
+        bytes_sent: 256,
+        response_flags: "-",
+    };
     let mut sink = std::io::sink();
 
     c.bench_function("Rust format!", |b| {
@@ -171,7 +174,12 @@ fn benchmark_log_formatter(c: &mut Criterion) {
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
     let start = InitContext { start_time: std::time::SystemTime::now() };
-    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    let end = FinishContext {
+        duration: Duration::from_millis(100),
+        bytes_received: 128,
+        bytes_sent: 256,
+        response_flags: "-",
+    };
 
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
     let mut sink = std::io::sink();
@@ -228,7 +236,12 @@ fn benchmark_request_parts(c: &mut Criterion) {
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
     let start = InitContext { start_time: std::time::SystemTime::now() };
-    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    let end = FinishContext {
+        duration: Duration::from_millis(100),
+        bytes_received: 128,
+        bytes_sent: 256,
+        response_flags: "-",
+    };
 
     let fmt = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
     c.bench_function("REQ(:PATH)", |b| {
@@ -255,29 +268,6 @@ fn benchmark_request_parts(c: &mut Criterion) {
     });
 }
 
-fn ret_small_cow() -> SmolCow<'static> {
-    SmolCow::Borrowed("123456789012345678901234567890")
-}
-
-fn ret_small_str() -> SmolStr {
-    SmolStr::new("123456789012345678901234567890")
-}
-
-fn benchmark_small_cow(c: &mut Criterion) {
-    c.bench_function("small_cow", |b| {
-        b.iter(|| {
-            let s = black_box(ret_small_cow());
-            black_box(s.into_owned());
-        })
-    });
-    c.bench_function("small_str", |b| {
-        b.iter(|| {
-            let s = black_box(ret_small_str());
-            black_box(s.clone());
-        })
-    });
-}
-
-criterion_group!(benches, benchmark_rust_format, benchmark_log_formatter, benchmark_request_parts, benchmark_small_cow);
+criterion_group!(benches, benchmark_rust_format, benchmark_log_formatter, benchmark_request_parts);
 
 criterion_main!(benches);
diff --git a/orion-format/src/bin/format-test.rs b/orion-format/src/bin/format-test.rs
index 24c89a6f..6f5018f0 100644
--- a/orion-format/src/bin/format-test.rs
+++ b/orion-format/src/bin/format-test.rs
@@ -33,7 +33,12 @@ fn main() {
 
     let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
     let start = InitContext { start_time: std::time::SystemTime::now() };
-    let end = FinishContext { duration: Duration::from_millis(100), bytes_received: 128, bytes_sent: 256 };
+    let end = FinishContext {
+        duration: Duration::from_millis(100),
+        bytes_received: 128,
+        bytes_sent: 256,
+        response_flags: "-",
+    };
 
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
     let mut sink = std::io::sink();
@@ -48,5 +53,9 @@ fn main() {
 
     let dur = now.elapsed();
 
-    println!("LogFormat: {:.2} msg/sec", TOTAL as f64 / dur.as_secs_f64());
+    println!(
+        "LogFormat: {:.2} msg/sec - avg duration {:.2} nsec",
+        TOTAL as f64 / dur.as_secs_f64(),
+        (dur.as_secs_f64() * 1_000_000_000.0) / TOTAL as f64
+    );
 }
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 4c38dbd0..abc2ca7c 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -1,7 +1,7 @@
 use std::time::{Duration, SystemTime};
 
 use chrono::{DateTime, Datelike, Timelike, Utc};
-use http::{Request, Response, Version};
+use http::{uri::Authority, Request, Response, Version};
 use smol_str::{SmolStr, SmolStrBuilder};
 
 use crate::{
@@ -10,7 +10,7 @@ use crate::{
 };
 
 pub trait Context {
-    fn eval_part<'a>(&'a self, token: &Token) -> Smol;
+    fn eval_part(&self, token: &Token) -> Smol;
     fn category() -> Category;
 }
 
@@ -20,17 +20,38 @@ pub struct InitContext {
 }
 
 #[derive(Clone, Debug)]
-pub struct FinishContext {
+pub struct FinishContext<'a> {
     pub duration: Duration,
     pub bytes_received: usize,
     pub bytes_sent: usize,
+    pub response_flags: &'a str,
+}
+
+#[derive(Clone, Debug)]
+pub struct UpstreamContext<'a> {
+    pub authority: &'a Authority,
+}
+
+#[derive(Clone, Debug)]
+pub struct DownstreamContext {}
+
+impl<'c> Context for UpstreamContext<'c> {
+    fn category() -> Category {
+        Category::UPSTREAM_CONTEXT
+    }
+    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
+        match token {
+            Token::UpstreamHost => Smol::Str(SmolStr::new(self.authority.host())),
+            _ => Smol::None,
+        }
+    }
 }
 
 impl Context for InitContext {
     fn category() -> Category {
         Category::INIT_CONTEXT
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
+    fn eval_part(&self, token: &Token) -> Smol {
         match token {
             Token::StartTime => Smol::Str(format_system_time(self.start_time)),
             _ => Smol::None,
@@ -38,12 +59,13 @@ impl Context for InitContext {
     }
 }
 
-impl Context for FinishContext {
+impl<'a> Context for FinishContext<'a> {
     fn category() -> Category {
         Category::FINISH_CONTEXT
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
+    fn eval_part(&self, token: &Token) -> Smol {
         match token {
+            Token::ResponseFlags => Smol::Str(SmolStr::new(self.response_flags)),
             Token::Duration => {
                 let mut buffer = itoa::Buffer::new();
                 Smol::Str(SmolStr::new(buffer.format(self.duration.as_millis())))
@@ -66,11 +88,11 @@ pub struct UpstreamRequest<'a, T>(pub &'a Request<T>);
 pub struct DownstreamResponse<'a, T>(pub &'a Response<T>);
 pub struct UpstreamResponse<'a, T>(pub &'a Response<T>);
 
-impl<'r, T> Context for DownstreamRequest<'r, T> {
+impl<'a, T> Context for DownstreamRequest<'a, T> {
     fn category() -> Category {
         Category::DOWNSTREAM_REQUEST
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
+    fn eval_part(&self, token: &Token) -> Smol {
         match token {
             Token::RequestPath => Smol::Str(SmolStr::new(self.0.uri().path())),
             Token::RequestAuthority => {
@@ -118,11 +140,11 @@ impl<'r, T> Context for DownstreamRequest<'r, T> {
     }
 }
 
-impl<'r, T> Context for DownstreamResponse<'r, T> {
+impl<'a, T> Context for DownstreamResponse<'a, T> {
     fn category() -> Category {
         Category::DOWNSTREAM_RESPONSE
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
+    fn eval_part(&self, token: &Token) -> Smol {
         match token {
             Token::ResponseCode => Smol::Str(SmolStr::new_inline(self.0.status().as_str())),
             Token::ResponseStandard(h) => {
diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index 3a736c83..c54dc432 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -60,7 +60,7 @@ lazy_static! {
         // trie_mapstr!(trie, "RESPONSE_FLAGS_LONG", Token::ResponseFlagsLong);
         // trie_mapstr!(trie, "UPSTREAM_HOST_NAME", Token::UpstreamHostName);
         // trie_mapstr!(trie, "UPSTREAM_HOST_NAME_WITHOUT_PORT", Token::UpstreamHostNameWithoutPort);
-        trie_mapstr!(trie, "UPSTREAM_HOST", Token::UpstreamHost, Category::UPSTREAM_REQUEST);
+        trie_mapstr!(trie, "UPSTREAM_HOST", Token::UpstreamHost, Category::UPSTREAM_CONTEXT);
         // trie_mapstr!(trie, "UPSTREAM_CONNECTION_ID", Token::UpstreamConnectionId);
         // trie_mapstr!(trie, "UPSTREAM_CLUSTER", Token::UpstreamCluster);
         // trie_mapstr!(trie, "UPSTREAM_CLUSTER_RAW", Token::UpstreamClusterRaw);
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index a1486739..4f210be6 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -1,6 +1,5 @@
 pub mod context;
 pub mod grammar;
-pub mod smol_cow;
 pub mod token;
 
 use context::Context;
@@ -121,7 +120,7 @@ mod tests {
 
     use http::{Request, Response, StatusCode};
 
-    use crate::context::{DownstreamRequest, DownstreamResponse, FinishContext, InitContext};
+    use crate::context::{DownstreamRequest, DownstreamResponse, FinishContext, InitContext, UpstreamContext};
 
     use super::*;
 
@@ -192,12 +191,14 @@ mod tests {
         let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
         let mut formatter = LogFormatter::try_new(def_fmt).unwrap();
         formatter.with_context(&InitContext { start_time: std::time::SystemTime::now() });
+        formatter.with_context(&UpstreamContext { authority: &req.uri().authority().unwrap() });
         formatter.with_context(&DownstreamRequest(&req));
         formatter.with_context(&DownstreamResponse(&resp));
         formatter.with_context(&FinishContext {
             duration: Duration::from_millis(100),
             bytes_received: 128,
             bytes_sent: 256,
+            response_flags: "UH",
         });
         println!("{}", &formatter);
     }
diff --git a/orion-format/src/token.rs b/orion-format/src/token.rs
index e419434a..eb7b1a2f 100644
--- a/orion-format/src/token.rs
+++ b/orion-format/src/token.rs
@@ -6,11 +6,13 @@ bitflags! {
     pub struct Category: u16 {
         const INIT_CONTEXT = 1;
         const FINISH_CONTEXT = 1 << 1;
-        const DOWNSTREAM_REQUEST = 1 << 1;
-        const DOWNSTREAM_RESPONSE = 1 << 2;
-        const UPSTREAM_REQUEST = 1 << 3;
-        const UPSTREAM_RESPONSE = 1 << 4;
-        const ARGUMENT = 1 << 5;
+        const UPSTREAM_CONTEXT = 1 << 2;
+        const DOWNSTREAM_CONTEXT = 1 << 3;
+        const DOWNSTREAM_REQUEST = 1 << 4;
+        const DOWNSTREAM_RESPONSE = 1 << 5;
+        const UPSTREAM_REQUEST = 1 << 6;
+        const UPSTREAM_RESPONSE = 1 << 7;
+        const ARGUMENT = 1 << 8;
     }
 }
 

From ebb0ae197edf75aa3336a6bc69fcb380c87269c7 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 16 May 2025 19:36:01 +0200
Subject: [PATCH 35/64] Refactor string handling to use unified StringType enum

- Replaced Smol enum with StringType to support multiple string types.
- Added CompactString support (currently commented out).
- Updated all context implementations to use StringType.
- Adjusted benchmarks and tests to reflect changes.
- Removed unused profile.bench section from Cargo.toml.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml             |  13 +--
 orion-format/benches/benchmark.rs   |  12 +--
 orion-format/src/bin/format-test.rs |   8 +-
 orion-format/src/context.rs         | 131 +++++++++++++++++++---------
 orion-format/src/lib.rs             |  26 +++---
 5 files changed, 117 insertions(+), 73 deletions(-)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index cc00e0b9..613a0919 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -18,22 +18,11 @@ chrono = "0.4.40"
 dhat = "0.3.3"
 bitflags = "2.9.0"
 itoa = "1.0.15"
+compact_str = "0.8.0"
 
 [features]
 dhat-heap = []
 
-[profile.bench]
-opt-level = 3
-lto = true
-codegen-units = 1
-debug = false
-strip = "debuginfo"
-debug-assertions = false
-overflow-checks = false
-panic = 'unwind'
-incremental = false
-rpath = false
-
 [[bench]]
 name = "benchmark"
 harness = false
diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index d0405010..ce588656 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -49,7 +49,7 @@ fn benchmark_rust_format(c: &mut Criterion) {
     };
     let mut sink = std::io::sink();
 
-    c.bench_function("Rust format!", |b| {
+    c.bench_function("rust_format!", |b| {
         b.iter(|| {
             let s =
                 black_box(eval_rust_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end));
@@ -59,7 +59,7 @@ fn benchmark_rust_format(c: &mut Criterion) {
 
     let default_haader_value = HeaderValue::from_static("");
 
-    c.bench_function("Rust format! (full clone)", |b| {
+    c.bench_function("rust_format!_full_clone", |b| {
         b.iter(|| {
             let start_time = start.start_time.clone();
             let datetime_utc: DateTime<Utc> = start_time.into();
@@ -184,13 +184,13 @@ fn benchmark_log_formatter(c: &mut Criterion) {
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
     let mut sink = std::io::sink();
 
-    c.bench_function("LogFormatter: clone only", |b| {
+    c.bench_function("log_formatter_clone_only", |b| {
         b.iter(|| {
             black_box(fmt.clone());
         })
     });
 
-    c.bench_function("LogFromatter (full)", |b| {
+    c.bench_function("log_formatter_full", |b| {
         b.iter(|| {
             let mut fmt = fmt.clone();
             black_box(eval_format(
@@ -203,7 +203,7 @@ fn benchmark_log_formatter(c: &mut Criterion) {
         })
     });
 
-    c.bench_function("LogFormatter (full) + write", |b| {
+    c.bench_function("log_formatter_full_write", |b| {
         b.iter(|| {
             let mut fmt = fmt.clone();
             black_box(eval_format(
@@ -220,7 +220,7 @@ fn benchmark_log_formatter(c: &mut Criterion) {
     let mut formatted = fmt.clone();
     eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut formatted);
 
-    c.bench_function("LogFormatter: write only", |b| {
+    c.bench_function("log_formatter_write_only", |b| {
         b.iter(|| {
             _ = black_box(|| formatted.write_to(&mut sink));
         })
diff --git a/orion-format/src/bin/format-test.rs b/orion-format/src/bin/format-test.rs
index 6f5018f0..9ab322cb 100644
--- a/orion-format/src/bin/format-test.rs
+++ b/orion-format/src/bin/format-test.rs
@@ -22,7 +22,7 @@ where
     fmt.with_context(end);
 }
 
-const TOTAL: u64 = 20_000_000;
+const TOTAL: u64 = 100_000_000;
 
 fn main() {
     let request = Request::builder()
@@ -41,14 +41,16 @@ fn main() {
     };
 
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
-    let mut sink = std::io::sink();
+    // let mut sink = std::io::sink();
+
+    println!("Running {} log format...", TOTAL);
 
     let now = Instant::now();
 
     for _ in 0..TOTAL {
         let mut fmt_ = black_box(fmt.clone());
         black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt_));
-        _ = black_box(|| fmt_.write_to(&mut sink));
+        // _ = black_box(|| fmt_.write_to(&mut sink));
     }
 
     let dur = now.elapsed();
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index abc2ca7c..eae22260 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -1,16 +1,17 @@
 use std::time::{Duration, SystemTime};
 
 use chrono::{DateTime, Datelike, Timelike, Utc};
+// use compact_str::CompactString;
 use http::{uri::Authority, Request, Response, Version};
 use smol_str::{SmolStr, SmolStrBuilder};
 
 use crate::{
     token::{Category, Token},
-    Smol,
+    StringType,
 };
 
 pub trait Context {
-    fn eval_part(&self, token: &Token) -> Smol;
+    fn eval_part(&self, token: &Token) -> StringType;
     fn category() -> Category;
 }
 
@@ -39,10 +40,10 @@ impl<'c> Context for UpstreamContext<'c> {
     fn category() -> Category {
         Category::UPSTREAM_CONTEXT
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> Smol {
+    fn eval_part<'a>(&'a self, token: &Token) -> StringType {
         match token {
-            Token::UpstreamHost => Smol::Str(SmolStr::new(self.authority.host())),
-            _ => Smol::None,
+            Token::UpstreamHost => StringType::Smol(SmolStr::new(self.authority.host())),
+            _ => StringType::None,
         }
     }
 }
@@ -51,10 +52,11 @@ impl Context for InitContext {
     fn category() -> Category {
         Category::INIT_CONTEXT
     }
-    fn eval_part(&self, token: &Token) -> Smol {
+    fn eval_part(&self, token: &Token) -> StringType {
         match token {
-            Token::StartTime => Smol::Str(format_system_time(self.start_time)),
-            _ => Smol::None,
+            // Token::StartTime => StringType::Compact(format_system_time_compact(self.start_time)),
+            Token::StartTime => StringType::Smol(format_system_time(self.start_time)),
+            _ => StringType::None,
         }
     }
 }
@@ -63,22 +65,22 @@ impl<'a> Context for FinishContext<'a> {
     fn category() -> Category {
         Category::FINISH_CONTEXT
     }
-    fn eval_part(&self, token: &Token) -> Smol {
+    fn eval_part(&self, token: &Token) -> StringType {
         match token {
-            Token::ResponseFlags => Smol::Str(SmolStr::new(self.response_flags)),
+            Token::ResponseFlags => StringType::Smol(SmolStr::new(self.response_flags)),
             Token::Duration => {
                 let mut buffer = itoa::Buffer::new();
-                Smol::Str(SmolStr::new(buffer.format(self.duration.as_millis())))
+                StringType::Smol(SmolStr::new(buffer.format(self.duration.as_millis())))
             },
             Token::BytesReceived => {
                 let mut buffer = itoa::Buffer::new();
-                Smol::Str(SmolStr::new(buffer.format(self.bytes_received)))
+                StringType::Smol(SmolStr::new(buffer.format(self.bytes_received)))
             },
             Token::BytesSent => {
                 let mut buffer = itoa::Buffer::new();
-                Smol::Str(SmolStr::new(buffer.format(self.bytes_sent)))
+                StringType::Smol(SmolStr::new(buffer.format(self.bytes_sent)))
             },
-            _ => Smol::None,
+            _ => StringType::None,
         }
     }
 }
@@ -92,22 +94,22 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
     fn category() -> Category {
         Category::DOWNSTREAM_REQUEST
     }
-    fn eval_part(&self, token: &Token) -> Smol {
+    fn eval_part(&self, token: &Token) -> StringType {
         match token {
-            Token::RequestPath => Smol::Str(SmolStr::new(self.0.uri().path())),
+            Token::RequestPath => StringType::Smol(SmolStr::new(self.0.uri().path())),
             Token::RequestAuthority => {
                 if let Some(a) = self.0.uri().authority() {
-                    Smol::Str(SmolStr::new(a.host()))
+                    StringType::Smol(SmolStr::new(a.host()))
                 } else {
-                    Smol::None
+                    StringType::None
                 }
             },
-            Token::RequestMethod => Smol::Str(SmolStr::new(self.0.method().as_str())),
+            Token::RequestMethod => StringType::Smol(SmolStr::new(self.0.method().as_str())),
             Token::RequestScheme => {
                 if let Some(s) = self.0.uri().scheme() {
-                    Smol::Str(SmolStr::new(s.as_str()))
+                    StringType::Smol(SmolStr::new(s.as_str()))
                 } else {
-                    Smol::None
+                    StringType::None
                 }
             },
 
@@ -116,12 +118,12 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
                 match hv {
                     Some(hv) => {
                         if let Some(s) = hv.to_str().ok() {
-                            Smol::Str(SmolStr::new(s))
+                            StringType::Smol(SmolStr::new(s))
                         } else {
-                            Smol::None
+                            StringType::None
                         }
                     },
-                    None => Smol::Str(SmolStr::new_static("")),
+                    None => StringType::Smol(SmolStr::new_static("")),
                 }
             },
             Token::Protocol => {
@@ -133,9 +135,9 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
                     _ => "HTTP/UNKNOWN",
                 };
 
-                Smol::Str(SmolStr::new_static(ver))
+                StringType::Smol(SmolStr::new_static(ver))
             },
-            _ => Smol::None,
+            _ => StringType::None,
         }
     }
 }
@@ -144,42 +146,43 @@ impl<'a, T> Context for DownstreamResponse<'a, T> {
     fn category() -> Category {
         Category::DOWNSTREAM_RESPONSE
     }
-    fn eval_part(&self, token: &Token) -> Smol {
+    fn eval_part(&self, token: &Token) -> StringType {
         match token {
-            Token::ResponseCode => Smol::Str(SmolStr::new_inline(self.0.status().as_str())),
+            Token::ResponseCode => StringType::Smol(SmolStr::new_inline(self.0.status().as_str())),
             Token::ResponseStandard(h) => {
                 let hv = self.0.headers().get(h.as_str());
                 match hv {
                     Some(hv) => {
                         if let Some(s) = hv.to_str().ok() {
-                            Smol::Str(SmolStr::new(s))
+                            StringType::Smol(SmolStr::new(s))
                         } else {
-                            Smol::None
+                            StringType::None
                         }
                     },
 
-                    None => Smol::Str(SmolStr::new_static("")),
+                    None => StringType::Smol(SmolStr::new_static("")),
                 }
             },
-            _ => Smol::None,
+            _ => StringType::None,
         }
     }
 }
 
+const TWO_DIGITS: [&str; 100] = [
+    "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17", "18",
+    "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37",
+    "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56",
+    "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75",
+    "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94",
+    "95", "96", "97", "98", "99",
+];
+
 pub fn format_system_time(time: SystemTime) -> SmolStr {
     let datetime: DateTime<Utc> = time.into();
+
     let mut builder = SmolStrBuilder::new();
     let mut buffer = itoa::Buffer::new();
 
-    const TWO_DIGITS: [&str; 100] = [
-        "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17",
-        "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35",
-        "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53",
-        "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71",
-        "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89",
-        "90", "91", "92", "93", "94", "95", "96", "97", "98", "99",
-    ];
-
     builder.push_str(buffer.format(datetime.year()));
     builder.push('-');
     builder.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.month() as usize) });
@@ -193,6 +196,52 @@ pub fn format_system_time(time: SystemTime) -> SmolStr {
     builder.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.second() as usize) });
     builder.push(':');
     builder.push_str(buffer.format(datetime.nanosecond() / 1_000_000));
+    // builder.push('Z');
 
     builder.finish()
 }
+
+#[cfg(any())]
+pub fn format_system_time_heapless(time: SystemTime) -> heapless::String<24> {
+    let datetime: DateTime<Utc> = time.into();
+    let mut rfc3999: heapless::String<24> = heapless::String::new();
+    let mut buffer = itoa::Buffer::new();
+    _ = rfc3999.push_str(buffer.format(datetime.year()));
+    _ = rfc3999.push('-');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.month() as usize) });
+    _ = rfc3999.push('-');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.day() as usize) });
+    _ = rfc3999.push('T');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.hour() as usize) });
+    _ = rfc3999.push(':');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.minute() as usize) });
+    _ = rfc3999.push(':');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.second() as usize) });
+    _ = rfc3999.push(':');
+    _ = rfc3999.push_str(buffer.format(datetime.nanosecond() / 1_000_000));
+    _ = rfc3999.push('Z');
+    rfc3999
+}
+
+#[cfg(any())]
+pub fn format_system_time_compact(time: SystemTime) -> CompactString {
+    let datetime: DateTime<Utc> = time.into();
+    let mut buffer = itoa::Buffer::new();
+    let mut rfc3999 = CompactString::default();
+
+    _ = rfc3999.push_str(buffer.format(datetime.year()));
+    _ = rfc3999.push('-');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.month() as usize) });
+    _ = rfc3999.push('-');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.day() as usize) });
+    _ = rfc3999.push('T');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.hour() as usize) });
+    _ = rfc3999.push(':');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.minute() as usize) });
+    _ = rfc3999.push(':');
+    _ = rfc3999.push_str(unsafe { TWO_DIGITS.get_unchecked(datetime.second() as usize) });
+    _ = rfc3999.push(':');
+    _ = rfc3999.push_str(buffer.format(datetime.nanosecond() / 1_000_000));
+    _ = rfc3999.push('Z');
+    rfc3999
+}
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 4f210be6..6da65dd1 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -2,6 +2,7 @@ pub mod context;
 pub mod grammar;
 pub mod token;
 
+// use compact_str::CompactString;
 use context::Context;
 use smol_str::SmolStr;
 use std::fmt::{self, Display, Formatter, Write};
@@ -38,28 +39,29 @@ pub enum Template {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-pub enum Smol {
-    Str(SmolStr),
+pub enum StringType {
     Char(char),
+    Smol(SmolStr),
+    // Compact(CompactString),
     None,
 }
 
 #[derive(PartialEq, Debug, Clone)]
 pub struct LogFormatter {
     pub template: Arc<Vec<Template>>,
-    pub format: Vec<Smol>,
+    pub format: Vec<StringType>,
 }
 
 impl LogFormatter {
     pub fn try_new(input: &str) -> Result<LogFormatter, FormatError> {
         let template = EnvoyGrammar::parse(input)?;
-        let mut format: Vec<Smol> = Vec::with_capacity(template.len());
+        let mut format: Vec<StringType> = Vec::with_capacity(template.len());
 
         for t in template.iter() {
             match t {
-                Template::Char(c) => format.push(Smol::Char(*c)),
-                Template::Literal(smol_str) => format.push(Smol::Str(smol_str.clone())),
-                _ => format.push(Smol::None),
+                Template::Char(c) => format.push(StringType::Char(*c)),
+                Template::Literal(smol_str) => format.push(StringType::Smol(smol_str.clone())),
+                _ => format.push(StringType::None),
             }
         }
 
@@ -83,12 +85,13 @@ impl LogFormatter {
         let mut total_bytes = 0;
         for (part, out) in self.template.iter().zip(self.format.iter()) {
             total_bytes += match out {
-                Smol::Str(s) => IoWrite::write(w, s.as_bytes())?,
-                Smol::Char(c) => {
+                StringType::Smol(s) => IoWrite::write(w, s.as_bytes())?,
+                StringType::Char(c) => {
                     let mut buf = [0u8; 4];
                     let bytes = c.encode_utf8(&mut buf).as_bytes();
                     IoWrite::write(w, bytes)?
                 },
+                // StringType::Compact(s) => IoWrite::write(w, s.as_bytes())?,
                 _ => IoWrite::write(w, format!("%{:?}%", part).as_bytes())?,
             };
         }
@@ -101,8 +104,9 @@ impl Display for LogFormatter {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         for (part, out) in self.template.iter().zip(self.format.iter()) {
             match out {
-                Smol::Str(s) => f.write_str(s.as_ref())?,
-                Smol::Char(c) => f.write_char(*c)?,
+                StringType::Smol(s) => f.write_str(s.as_ref())?,
+                StringType::Char(c) => f.write_char(*c)?,
+                // StringType::Compact(s) => f.write_str(s.as_ref())?,
                 _ => f.write_str(&format!("%{:?}%", part))?,
             };
         }

From 3f8576eb1aca26eca0a31fbd7218d2cff4ea5bcf Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 19 May 2025 07:54:33 +0200
Subject: [PATCH 36/64] Add support for X-Envoy-Original-Path header in request
 context

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/context.rs | 64 ++++++++++++++++++++++++++++++++++++-
 orion-format/src/grammar.rs |  3 +-
 orion-format/src/lib.rs     | 26 ++++++++++++---
 orion-format/src/token.rs   |  1 +
 4 files changed, 88 insertions(+), 6 deletions(-)

diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index eae22260..26c7b536 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -2,7 +2,7 @@ use std::time::{Duration, SystemTime};
 
 use chrono::{DateTime, Datelike, Timelike, Utc};
 // use compact_str::CompactString;
-use http::{uri::Authority, Request, Response, Version};
+use http::{uri::Authority, HeaderName, Request, Response, Version};
 use smol_str::{SmolStr, SmolStrBuilder};
 
 use crate::{
@@ -90,6 +90,68 @@ pub struct UpstreamRequest<'a, T>(pub &'a Request<T>);
 pub struct DownstreamResponse<'a, T>(pub &'a Response<T>);
 pub struct UpstreamResponse<'a, T>(pub &'a Response<T>);
 
+impl<'a, T> Context for UpstreamRequest<'a, T> {
+    fn category() -> Category {
+        Category::UPSTREAM_REQUEST
+    }
+    fn eval_part(&self, token: &Token) -> StringType {
+        match token {
+            Token::RequestPath => StringType::Smol(SmolStr::new(self.0.uri().path())),
+            Token::RequestOriginalPathOrPath => {
+                let path_str = self
+                    .0
+                    .headers()
+                    .get(HeaderName::from_static("x-envoy-original-path"))
+                    .and_then(|p| p.to_str().ok())
+                    .unwrap_or_else(|| self.0.uri().path());
+
+                StringType::Smol(SmolStr::new(path_str))
+            },
+            Token::RequestAuthority => {
+                if let Some(a) = self.0.uri().authority() {
+                    StringType::Smol(SmolStr::new(a.host()))
+                } else {
+                    StringType::None
+                }
+            },
+            Token::RequestMethod => StringType::Smol(SmolStr::new(self.0.method().as_str())),
+            Token::RequestScheme => {
+                if let Some(s) = self.0.uri().scheme() {
+                    StringType::Smol(SmolStr::new(s.as_str()))
+                } else {
+                    StringType::None
+                }
+            },
+
+            Token::RequestStandard(h) => {
+                let hv = self.0.headers().get(h);
+                match hv {
+                    Some(hv) => {
+                        if let Some(s) = hv.to_str().ok() {
+                            StringType::Smol(SmolStr::new(s))
+                        } else {
+                            StringType::None
+                        }
+                    },
+                    None => StringType::Smol(SmolStr::new_static("")),
+                }
+            },
+            Token::Protocol => {
+                let ver = match self.0.version() {
+                    Version::HTTP_10 => "HTTP/1.0",
+                    Version::HTTP_11 => "HTTP/1.1",
+                    Version::HTTP_2 => "HTTP/2",
+                    Version::HTTP_3 => "HTTP/3",
+                    _ => "HTTP/UNKNOWN",
+                };
+
+                StringType::Smol(SmolStr::new_static(ver))
+            },
+            _ => StringType::None,
+        }
+    }
+}
+
 impl<'a, T> Context for DownstreamRequest<'a, T> {
     fn category() -> Category {
         Category::DOWNSTREAM_REQUEST
diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index c54dc432..0c8df21c 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -20,6 +20,7 @@ lazy_static! {
         trie_mapstr!(trie, ":METHOD",Token::RequestMethod, Category::ARGUMENT);
         trie_mapstr!(trie, ":PATH", Token::RequestPath, Category::ARGUMENT);
         trie_mapstr!(trie, ":AUTHORITY", Token::RequestAuthority, Category::ARGUMENT);
+        trie_mapstr!(trie, "X-ENVOY-ORIGINAL-PATH?:PATH", Token::RequestOriginalPathOrPath, Category::ARGUMENT);
         trie
     };
 
@@ -383,7 +384,7 @@ mod tests {
 
     #[test]
     fn test_default_fmt() {
-        let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%"
+        let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%"
             %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION%
             %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%"
             "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 6da65dd1..5c49cb79 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -122,9 +122,11 @@ pub trait Grammar {
 mod tests {
     use std::time::Duration;
 
-    use http::{Request, Response, StatusCode};
+    use http::{HeaderValue, Request, Response, StatusCode};
 
-    use crate::context::{DownstreamRequest, DownstreamResponse, FinishContext, InitContext, UpstreamContext};
+    use crate::context::{
+        DownstreamRequest, DownstreamResponse, FinishContext, InitContext, UpstreamContext, UpstreamRequest,
+    };
 
     use super::*;
 
@@ -139,10 +141,26 @@ mod tests {
 
     #[test]
     fn test_request_path() {
-        let req = build_request();
+        let mut req = build_request();
+        req.headers_mut().append("X-ENVOY-ORIGINAL-PATH", HeaderValue::from_static("/original"));
+
         let mut formatter = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
         let expected = "/";
-        formatter.with_context(&DownstreamRequest(&req));
+
+        formatter.with_context(&UpstreamRequest(&req));
+        let actual = format!("{}", &formatter);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_request_original_path() {
+        let mut req = build_request();
+        req.headers_mut().append("X-ENVOY-ORIGINAL-PATH", HeaderValue::from_static("/original"));
+
+        let mut formatter = LogFormatter::try_new("%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)%").unwrap();
+        let expected = "/original";
+
+        formatter.with_context(&UpstreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
diff --git a/orion-format/src/token.rs b/orion-format/src/token.rs
index eb7b1a2f..9bef89a4 100644
--- a/orion-format/src/token.rs
+++ b/orion-format/src/token.rs
@@ -136,6 +136,7 @@ pub enum Token {
     RequestScheme,
     RequestMethod,
     RequestPath,
+    RequestOriginalPathOrPath,
     RequestAuthority,
     RequestStandard(HeaderName),
     Response, // placeholder

From 3a93b03bccc87c51ef2824d5f1a958e531b34200 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 19 May 2025 08:30:20 +0200
Subject: [PATCH 37/64] Refactor response flags handling and improve logging

- Introduced `ResponseFlags` using `bitflags` for better flag management.
- Added `ResponseFlagsShort` and `ResponseFlagsLong` for flag representations.
- Updated log formatting to use the new `ResponseFlags` structure.
- Adjusted benchmarks and tests to reflect the changes.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs   | 113 +++++-------------
 orion-format/src/bin/format-test.rs |   5 +-
 orion-format/src/context.rs         |  88 +++++---------
 orion-format/src/grammar.rs         |  12 +-
 orion-format/src/lib.rs             |  41 +++++--
 orion-format/src/types.rs           | 172 ++++++++++++++++++++++++++++
 6 files changed, 270 insertions(+), 161 deletions(-)
 create mode 100644 orion-format/src/types.rs

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index ce588656..f8960906 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -1,18 +1,18 @@
 use chrono::{DateTime, SecondsFormat, Utc};
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use http::{HeaderMap, HeaderValue, Request, Response, StatusCode, Version};
+use http::{HeaderMap, HeaderName, HeaderValue, Request, Response, StatusCode, Version};
 use orion_format::{
     context::{Context, DownstreamRequest, DownstreamResponse, FinishContext, InitContext},
-    LogFormatter,
+    types::{ResponseFlags, ResponseFlagsShort},
+    LogFormatter, DEFAULT_ENVOY_FORMAT,
 };
+use smol_str::ToSmolStr;
 use std::time::Duration;
 
 #[cfg(feature = "dhat-heap")]
 #[global_allocator]
 static ALLOC: dhat::Alloc = dhat::Alloc;
 
-const DEF_FMT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
-
 #[inline]
 fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter)
 where
@@ -45,21 +45,13 @@ fn benchmark_rust_format(c: &mut Criterion) {
         duration: Duration::from_millis(100),
         bytes_received: 128,
         bytes_sent: 256,
-        response_flags: "-",
+        response_flags: ResponseFlags::empty(),
     };
-    let mut sink = std::io::sink();
-
-    c.bench_function("rust_format!", |b| {
-        b.iter(|| {
-            let s =
-                black_box(eval_rust_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end));
-            _ = black_box(write_to_format(&mut sink, s.as_bytes()));
-        })
-    });
 
     let default_haader_value = HeaderValue::from_static("");
+    let upstream_host: String = "www.upstream.com".into();
 
-    c.bench_function("rust_format!_full_clone", |b| {
+    c.bench_function("rust_format!", |b| {
         b.iter(|| {
             let start_time = start.start_time.clone();
             let datetime_utc: DateTime<Utc> = start_time.into();
@@ -67,7 +59,6 @@ fn benchmark_rust_format(c: &mut Criterion) {
 
             let method = request.method().clone();
             let uri = request.uri().clone();
-
             let protocol = request.version().clone();
             let ver = match protocol {
                 Version::HTTP_10 => "HTTP/1.0",
@@ -85,14 +76,23 @@ fn benchmark_rust_format(c: &mut Criterion) {
             let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers(), &default_haader_value);
             let user_agent = header_lookup("USER-AGENT", request.headers(), &default_haader_value);
             let x_request_id = header_lookup("X-REQUEST-ID", request.headers(), &default_haader_value);
+            let upstream_host = upstream_host.clone();
+
+            let path: String = request
+                .headers()
+                .get(HeaderName::from_static("x-envoy-original-path"))
+                .and_then(|p| p.to_str().ok())
+                .unwrap_or_else(|| request.uri().path())
+                .into();
 
             black_box(format!(
-                r#"[{}] "{} {} {} {} %RESPONSE_FLAGS% {} {} {} {} {} {} {} {} "%UPSTREAM_HOST%""#,
+                r#"[{}] "{} {} {} {} {} {} {} {} {} {} {} {} {} "{}""#,
                 rfc3339,
                 method.as_str(),
-                uri.path(),
+                path,
                 ver,
                 response_code.as_u16(),
+                ResponseFlagsShort(&ResponseFlags::empty()).to_smolstr(),
                 end_context.bytes_received,
                 end_context.bytes_sent,
                 end_context.duration.as_millis(),
@@ -100,68 +100,13 @@ fn benchmark_rust_format(c: &mut Criterion) {
                 x_forwarded_for.to_str().unwrap(),
                 user_agent.to_str().unwrap(),
                 x_request_id.to_str().unwrap(),
-                uri.authority().unwrap().host()
+                uri.authority().unwrap().host(),
+                upstream_host,
             ));
         });
     });
 }
 
-fn write_to_format<W: std::io::Write>(w: &mut W, log: &[u8]) -> std::io::Result<usize> {
-    let len = w.write(log)?;
-    Ok(len)
-}
-
-fn eval_rust_format(
-    request: &DownstreamRequest<()>,
-    response: &DownstreamResponse<()>,
-    init_context: &InitContext,
-    finish_context: &FinishContext,
-) -> String {
-    let request = request.0;
-    let response = response.0;
-    let start_time = &init_context.start_time;
-    let datetime_utc: DateTime<Utc> = start_time.clone().into();
-    let rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
-
-    let method = request.method();
-    let uri = request.uri();
-
-    let protocol = request.version();
-    let ver = match protocol {
-        Version::HTTP_10 => "HTTP/1.0",
-        Version::HTTP_11 => "HTTP/1.1",
-        Version::HTTP_2 => "HTTP/2",
-        Version::HTTP_3 => "HTTP/3",
-        _ => "HTTP/UNKNOWN",
-    };
-
-    let response_code = response.status();
-
-    let default_header: HeaderValue = HeaderValue::from_static("");
-    let x_envoy_upstream_service_time =
-        header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers(), &default_header);
-    let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers(), &default_header);
-    let user_agent = header_lookup("USER-AGENT", request.headers(), &default_header);
-    let x_request_id = header_lookup("X-REQUEST-ID", request.headers(), &default_header);
-
-    format!(
-        r#"[{}] "{} {} {} {} %RESPONSE_FLAGS% {} {} {} {} {} {} {} {} "%UPSTREAM_HOST%""#,
-        rfc3339,
-        method.as_str(),
-        uri.path(),
-        ver,
-        response_code.as_u16(),
-        finish_context.bytes_received,
-        finish_context.bytes_sent,
-        finish_context.duration.as_millis(),
-        x_envoy_upstream_service_time.to_str().unwrap(),
-        x_forwarded_for.to_str().unwrap(),
-        user_agent.to_str().unwrap(),
-        x_request_id.to_str().unwrap(),
-        uri.authority().unwrap().host()
-    )
-}
-
 fn benchmark_log_formatter(c: &mut Criterion) {
     #[cfg(feature = "dhat-heap")]
     let _profiler = dhat::Profiler::new_heap();
@@ -178,18 +123,12 @@ fn benchmark_log_formatter(c: &mut Criterion) {
         duration: Duration::from_millis(100),
         bytes_received: 128,
         bytes_sent: 256,
-        response_flags: "-",
+        response_flags: ResponseFlags::empty(),
     };
 
-    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
+    let fmt = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap();
     let mut sink = std::io::sink();
 
-    c.bench_function("log_formatter_clone_only", |b| {
-        b.iter(|| {
-            black_box(fmt.clone());
-        })
-    });
-
     c.bench_function("log_formatter_full", |b| {
         b.iter(|| {
             let mut fmt = fmt.clone();
@@ -217,6 +156,12 @@ fn benchmark_log_formatter(c: &mut Criterion) {
         })
     });
 
+    c.bench_function("log_formatter_clone_only", |b| {
+        b.iter(|| {
+            black_box(fmt.clone());
+        })
+    });
+
     let mut formatted = fmt.clone();
     eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut formatted);
 
@@ -240,7 +185,7 @@ fn benchmark_request_parts(c: &mut Criterion) {
         duration: Duration::from_millis(100),
         bytes_received: 128,
         bytes_sent: 256,
-        response_flags: "-",
+        response_flags: ResponseFlags::empty(),
     };
 
     let fmt = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
diff --git a/orion-format/src/bin/format-test.rs b/orion-format/src/bin/format-test.rs
index 9ab322cb..bf83baf7 100644
--- a/orion-format/src/bin/format-test.rs
+++ b/orion-format/src/bin/format-test.rs
@@ -2,11 +2,12 @@ use criterion::black_box;
 use http::{Request, Response, StatusCode};
 use orion_format::{
     context::{Context, DownstreamRequest, DownstreamResponse, FinishContext, InitContext},
+    types::ResponseFlags,
     LogFormatter,
 };
 use std::time::{Duration, Instant};
 
-const DEF_FMT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+const DEF_FMT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
 
 #[inline]
 fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter)
@@ -37,7 +38,7 @@ fn main() {
         duration: Duration::from_millis(100),
         bytes_received: 128,
         bytes_sent: 256,
-        response_flags: "-",
+        response_flags: ResponseFlags::empty(),
     };
 
     let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 26c7b536..86c0518e 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -3,13 +3,16 @@ use std::time::{Duration, SystemTime};
 use chrono::{DateTime, Datelike, Timelike, Utc};
 // use compact_str::CompactString;
 use http::{uri::Authority, HeaderName, Request, Response, Version};
-use smol_str::{SmolStr, SmolStrBuilder};
+use smol_str::{SmolStr, SmolStrBuilder, ToSmolStr};
 
 use crate::{
     token::{Category, Token},
+    types::{ResponseFlags, ResponseFlagsShort},
     StringType,
 };
 
+const X_ENVOY_ORIGINAL_PATH: HeaderName = HeaderName::from_static("x-envoy-original-path");
+
 pub trait Context {
     fn eval_part(&self, token: &Token) -> StringType;
     fn category() -> Category;
@@ -21,11 +24,11 @@ pub struct InitContext {
 }
 
 #[derive(Clone, Debug)]
-pub struct FinishContext<'a> {
+pub struct FinishContext {
     pub duration: Duration,
     pub bytes_received: usize,
     pub bytes_sent: usize,
-    pub response_flags: &'a str,
+    pub response_flags: ResponseFlags,
 }
 
 #[derive(Clone, Debug)]
@@ -61,13 +64,13 @@ impl Context for InitContext {
     }
 }
 
-impl<'a> Context for FinishContext<'a> {
+impl Context for FinishContext {
     fn category() -> Category {
         Category::FINISH_CONTEXT
     }
     fn eval_part(&self, token: &Token) -> StringType {
         match token {
-            Token::ResponseFlags => StringType::Smol(SmolStr::new(self.response_flags)),
+            Token::ResponseFlags => StringType::Smol(ResponseFlagsShort(&self.response_flags).to_smolstr()),
             Token::Duration => {
                 let mut buffer = itoa::Buffer::new();
                 StringType::Smol(SmolStr::new(buffer.format(self.duration.as_millis())))
@@ -90,9 +93,9 @@ pub struct UpstreamRequest<'a, T>(pub &'a Request<T>);
 pub struct DownstreamResponse<'a, T>(pub &'a Response<T>);
 pub struct UpstreamResponse<'a, T>(pub &'a Response<T>);
 
-impl<'a, T> Context for UpstreamRequest<'a, T> {
+impl<'a, T> Context for DownstreamRequest<'a, T> {
     fn category() -> Category {
-        Category::UPSTREAM_REQUEST
+        Category::DOWNSTREAM_REQUEST
     }
     fn eval_part(&self, token: &Token) -> StringType {
         match token {
@@ -101,7 +104,7 @@ impl<'a, T> Context for UpstreamRequest<'a, T> {
                 let path_str = self
                     .0
                     .headers()
-                    .get(HeaderName::from_static("x-envoy-original-path"))
+                    .get(X_ENVOY_ORIGINAL_PATH)
                     .and_then(|p| p.to_str().ok())
                     .unwrap_or_else(|| self.0.uri().path());
 
@@ -136,69 +139,19 @@ impl<'a, T> Context for UpstreamRequest<'a, T> {
                     None => StringType::Smol(SmolStr::new_static("")),
                 }
             },
-            Token::Protocol => {
-                let ver = match self.0.version() {
-                    Version::HTTP_10 => "HTTP/1.0",
-                    Version::HTTP_11 => "HTTP/1.1",
-                    Version::HTTP_2 => "HTTP/2",
-                    Version::HTTP_3 => "HTTP/3",
-                    _ => "HTTP/UNKNOWN",
-                };
-
-                StringType::Smol(SmolStr::new_static(ver))
-            },
+            Token::Protocol => StringType::Smol(SmolStr::new_static(into_protocol(self.0.version()))),
             _ => StringType::None,
         }
     }
 }
 
-impl<'a, T> Context for DownstreamRequest<'a, T> {
+impl<'a, T> Context for UpstreamRequest<'a, T> {
     fn category() -> Category {
-        Category::DOWNSTREAM_REQUEST
+        Category::UPSTREAM_REQUEST
     }
     fn eval_part(&self, token: &Token) -> StringType {
         match token {
-            Token::RequestPath => StringType::Smol(SmolStr::new(self.0.uri().path())),
-            Token::RequestAuthority => {
-                if let Some(a) = self.0.uri().authority() {
-                    StringType::Smol(SmolStr::new(a.host()))
-                } else {
-                    StringType::None
-                }
-            },
-            Token::RequestMethod => StringType::Smol(SmolStr::new(self.0.method().as_str())),
-            Token::RequestScheme => {
-                if let Some(s) = self.0.uri().scheme() {
-                    StringType::Smol(SmolStr::new(s.as_str()))
-                } else {
-                    StringType::None
-                }
-            },
-
-            Token::RequestStandard(h) => {
-                let hv = self.0.headers().get(h);
-                match hv {
-                    Some(hv) => {
-                        if let Some(s) = hv.to_str().ok() {
-                            StringType::Smol(SmolStr::new(s))
-                        } else {
-                            StringType::None
-                        }
-                    },
-                    None => StringType::Smol(SmolStr::new_static("")),
-                }
-            },
-            Token::Protocol => {
-                let ver = match self.0.version() {
-                    Version::HTTP_10 => "HTTP/1.0",
-                    Version::HTTP_11 => "HTTP/1.1",
-                    Version::HTTP_2 => "HTTP/2",
-                    Version::HTTP_3 => "HTTP/3",
-                    _ => "HTTP/UNKNOWN",
-                };
-
-                StringType::Smol(SmolStr::new_static(ver))
-            },
+            Token::UpstreamProtocol => StringType::Smol(SmolStr::new_static(into_protocol(self.0.version()))),
             _ => StringType::None,
         }
     }
@@ -263,6 +216,17 @@ pub fn format_system_time(time: SystemTime) -> SmolStr {
     builder.finish()
 }
 
+#[inline]
+fn into_protocol(ver: Version) -> &'static str {
+    match ver {
+        Version::HTTP_10 => "HTTP/1.0",
+        Version::HTTP_11 => "HTTP/1.1",
+        Version::HTTP_2 => "HTTP/2",
+        Version::HTTP_3 => "HTTP/3",
+        _ => "HTTP/UNKNOWN",
+    }
+}
+
 #[cfg(any())]
 pub fn format_system_time_heapless(time: SystemTime) -> heapless::String<24> {
     let datetime: DateTime<Utc> = time.into();
diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index 0c8df21c..109d0900 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -45,7 +45,7 @@ lazy_static! {
         // trie_mapstr!(trie, "DOWNSTREAM_WIRE_BYTES_RECEIVED", Token::DownstreamWireBytesReceived);
         // trie_mapstr!(trie, "DOWNSTREAM_HEADER_BYTES_RECEIVED", Token::DownstreamHeaderBytesReceived);
         trie_mapstr!(trie, "PROTOCOL", Token::Protocol, Category::DOWNSTREAM_REQUEST);
-        // trie_mapstr!(trie, "UPSTREAM_PROTOCOL", Token::UpstreamProtocol);
+        trie_mapstr!(trie, "UPSTREAM_PROTOCOL", Token::UpstreamProtocol, Category::UPSTREAM_REQUEST);
         trie_mapstr!(trie, "RESPONSE_CODE", Token::ResponseCode, Category::DOWNSTREAM_RESPONSE);
         // trie_mapstr!(trie, "RESPONSE_CODE_DETAILS", Token::ResponseCodeDetails);
         // trie_mapstr!(trie, "CONNECTION_TERMINATION_DETAILS", Token::ConnectionTerminationDetails);
@@ -145,8 +145,8 @@ lazy_static! {
         // trie_mapstr!(trie, "UPSTREAM_PEER_CERT_V_END", Token::UpstreamPeerCertVEnd);
         // trie_mapstr!(trie, "ENVIRONMENT", Token::Environment);
         // trie_mapstr!(trie, "UPSTREAM_CONNECTION_POOL_READY_DURATION", Token::UpstreamConnectionPoolReadyDuration);
-        trie_mapstr!(trie, "REQ", Token::Request, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST, true); // %REQ(USER-AGENT)%
-        trie_mapstr!(trie, "RESP", Token::Response, Category::DOWNSTREAM_RESPONSE | Category::UPSTREAM_RESPONSE , true); // %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)%
+        trie_mapstr!(trie, "REQ", Token::Request, Category::DOWNSTREAM_REQUEST, true); // %REQ(USER-AGENT)%
+        trie_mapstr!(trie, "RESP", Token::Response, Category::DOWNSTREAM_RESPONSE, true); // %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)%
         trie
     };
 }
@@ -317,7 +317,7 @@ mod tests {
         let input = "Start %REQ(:METHOD)% middle %PROTOCOL% end.";
         let expected = vec![
             Template::Literal("Start ".into()),
-            Template::Placeholder(Token::RequestMethod, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST),
+            Template::Placeholder(Token::RequestMethod, Category::DOWNSTREAM_REQUEST),
             Template::Literal(" middle ".into()),
             Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
             Template::Literal(" end.".into()),
@@ -371,9 +371,9 @@ mod tests {
             Template::Char('['),
             Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT),
             Template::Literal("] \"".into()),
-            Template::Placeholder(Token::RequestMethod, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST),
+            Template::Placeholder(Token::RequestMethod, Category::DOWNSTREAM_REQUEST),
             Template::Char(' '),
-            Template::Placeholder(Token::RequestPath, Category::DOWNSTREAM_REQUEST | Category::UPSTREAM_REQUEST),
+            Template::Placeholder(Token::RequestPath, Category::DOWNSTREAM_REQUEST),
             Template::Char(' '),
             Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
             Template::Char('"'),
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 5c49cb79..59697072 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -1,6 +1,7 @@
 pub mod context;
 pub mod grammar;
 pub mod token;
+pub mod types;
 
 // use compact_str::CompactString;
 use context::Context;
@@ -13,6 +14,8 @@ use token::{Category, Token};
 
 use crate::grammar::EnvoyGrammar;
 
+pub const DEFAULT_ENVOY_FORMAT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+
 #[derive(Error, Debug)]
 pub enum FormatError {
     #[error("pattern `{0}` not supported")]
@@ -124,8 +127,11 @@ mod tests {
 
     use http::{HeaderValue, Request, Response, StatusCode};
 
-    use crate::context::{
-        DownstreamRequest, DownstreamResponse, FinishContext, InitContext, UpstreamContext, UpstreamRequest,
+    use crate::{
+        context::{
+            DownstreamRequest, DownstreamResponse, FinishContext, InitContext, UpstreamContext, UpstreamRequest,
+        },
+        types::ResponseFlags,
     };
 
     use super::*;
@@ -147,7 +153,7 @@ mod tests {
         let mut formatter = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
         let expected = "/";
 
-        formatter.with_context(&UpstreamRequest(&req));
+        formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -160,7 +166,7 @@ mod tests {
         let mut formatter = LogFormatter::try_new("%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)%").unwrap();
         let expected = "/original";
 
-        formatter.with_context(&UpstreamRequest(&req));
+        formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
         assert_eq!(actual, expected);
     }
@@ -176,6 +182,28 @@ mod tests {
         assert_eq!(actual, expected);
     }
 
+    #[test]
+    fn test_request_protocol() {
+        let req = build_request();
+        let mut formatter = LogFormatter::try_new("%PROTOCOL%").unwrap();
+        println!("FORMATTER: {:?}", formatter);
+        let expected = "HTTP/1.1";
+        formatter.with_context(&DownstreamRequest(&req));
+        let actual = format!("{}", &formatter);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_request_upstream_protocol() {
+        let req = build_request();
+        let mut formatter = LogFormatter::try_new("%UPSTREAM_PROTOCOL%").unwrap();
+        println!("FORMATTER: {:?}", formatter);
+        let expected = "HTTP/1.1";
+        formatter.with_context(&UpstreamRequest(&req));
+        let actual = format!("{}", &formatter);
+        assert_eq!(actual, expected);
+    }
+
     #[test]
     fn test_request_scheme() {
         let req = build_request();
@@ -210,8 +238,7 @@ mod tests {
     fn default_format_string() {
         let req = build_request();
         let resp = build_response();
-        let def_fmt = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
-        let mut formatter = LogFormatter::try_new(def_fmt).unwrap();
+        let mut formatter = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap();
         formatter.with_context(&InitContext { start_time: std::time::SystemTime::now() });
         formatter.with_context(&UpstreamContext { authority: &req.uri().authority().unwrap() });
         formatter.with_context(&DownstreamRequest(&req));
@@ -220,7 +247,7 @@ mod tests {
             duration: Duration::from_millis(100),
             bytes_received: 128,
             bytes_sent: 256,
-            response_flags: "UH",
+            response_flags: ResponseFlags::NO_HEALTHY_UPSTREAM,
         });
         println!("{}", &formatter);
     }
diff --git a/orion-format/src/types.rs b/orion-format/src/types.rs
new file mode 100644
index 00000000..7e36fb9c
--- /dev/null
+++ b/orion-format/src/types.rs
@@ -0,0 +1,172 @@
+use bitflags::{bitflags, bitflags_match};
+use smol_str::{SmolStr, SmolStrBuilder, ToSmolStr};
+
+bitflags! {
+    #[derive(PartialEq, Clone, Debug)]
+    pub struct ResponseFlags: u32 {
+        const NO_HEALTHY_UPSTREAM                   = 0b000000000000000000000000000001;
+        const UPSTREAM_CONNECTION_FAILURE           = 0b000000000000000000000000000010;
+        const UPSTREAM_OVERFLOW                     = 0b000000000000000000000000000100;
+        const NO_ROUTE_FOUND                        = 0b000000000000000000000000001000;
+        const UPSTREAM_RETRY_LIMIT_EXCEEDED         = 0b000000000000000000000000010000;
+        const NO_CLUSTER_FOUND                      = 0b000000000000000000000000100000;
+        const DURATION_TIMEOUT                      = 0b000000000000000000000001000000;
+        const DOWNSTREAM_CONNECTION_TERMINATION     = 0b000000000000000000000010000000;
+        const FAILED_LOCAL_HEALTH_CHECK             = 0b000000000000000000000100000000;
+        const UPSTREAM_REQUEST_TIMEOUT              = 0b000000000000000000001000000000;
+        const LOCAL_RESET                           = 0b000000000000000000010000000000;
+        const UPSTREAM_REMOTE_RESET                 = 0b000000000000000000100000000000;
+        const UPSTREAM_CONNECTION_TERMINATION       = 0b000000000000000001000000000000;
+        const DELAY_INJECTED                        = 0b000000000000000010000000000000;
+        const FAULT_INJECTED                        = 0b000000000000000100000000000000;
+        const RATE_LIMITED                          = 0b000000000000001000000000000000;
+        const UNAUTHORIZED_EXTERNAL_SERVICE         = 0b000000000000010000000000000000;
+        const RATE_LIMIT_SERVICE_ERROR              = 0b000000000000100000000000000000;
+        const INVALID_ENVOY_REQUEST_HEADERS         = 0b000000000001000000000000000000;
+        const STREAM_IDLE_TIMEOUT                   = 0b000000000010000000000000000000;
+        const DOWNSTREAM_PROTOCOL_ERROR             = 0b000000000100000000000000000000;
+        const UPSTREAM_PROTOCOL_ERROR               = 0b000000001000000000000000000000;
+        const UPSTREAM_MAX_STREAM_DURATION_REACHED  = 0b000000010000000000000000000000;
+        const RESPONSE_FROM_CACHE_FILTER            = 0b000000100000000000000000000000;
+        const NO_FILTER_CONFIG_FOUND                = 0b000001000000000000000000000000;
+        const OVERLOAD_MANAGER_TERMINATED           = 0b000010000000000000000000000000;
+        const DNS_RESOLUTION_FAILED                 = 0b000100000000000000000000000000;
+        const DROP_OVERLOAD                         = 0b001000000000000000000000000000;
+        const DOWNSTREAM_REMOTE_RESET               = 0b010000000000000000000000000000;
+        const UNCONDITIONAL_DROP_OVERLOAD           = 0b100000000000000000000000000000;
+    }
+}
+
+pub struct ResponseFlagsShort<'a>(pub &'a ResponseFlags);
+pub struct ResponseFlagsLong<'a>(pub &'a ResponseFlags);
+
+impl<'a> ToSmolStr for ResponseFlagsShort<'a> {
+    fn to_smolstr(&self) -> SmolStr {
+        if self.0.is_empty() {
+            return SmolStr::new_static("-");
+        }
+        let mut flags = SmolStrBuilder::new();
+        let mut i = 0;
+
+        for f in self.0.clone() {
+            if i > 0 {
+                flags.push(',');
+            }
+            bitflags_match!(f, {
+                ResponseFlags::NO_HEALTHY_UPSTREAM                   => flags.push_str("UH"),
+                ResponseFlags::UPSTREAM_CONNECTION_FAILURE           => flags.push_str("UF"),
+                ResponseFlags::UPSTREAM_OVERFLOW                     => flags.push_str("UO"),
+                ResponseFlags::NO_ROUTE_FOUND                        => flags.push_str("NR"),
+                ResponseFlags::UPSTREAM_RETRY_LIMIT_EXCEEDED         => flags.push_str("URX"),
+                ResponseFlags::NO_CLUSTER_FOUND                      => flags.push_str("NC"),
+                ResponseFlags::DURATION_TIMEOUT                      => flags.push_str("DT"),
+                ResponseFlags::DOWNSTREAM_CONNECTION_TERMINATION     => flags.push_str("DC"),
+                ResponseFlags::FAILED_LOCAL_HEALTH_CHECK             => flags.push_str("LH"),
+                ResponseFlags::UPSTREAM_REQUEST_TIMEOUT              => flags.push_str("UT"),
+                ResponseFlags::LOCAL_RESET                           => flags.push_str("LR"),
+                ResponseFlags::UPSTREAM_REMOTE_RESET                 => flags.push_str("UR"),
+                ResponseFlags::UPSTREAM_CONNECTION_TERMINATION       => flags.push_str("UC"),
+                ResponseFlags::DELAY_INJECTED                        => flags.push_str("DI"),
+                ResponseFlags::FAULT_INJECTED                        => flags.push_str("FI"),
+                ResponseFlags::RATE_LIMITED                          => flags.push_str("RL"),
+                ResponseFlags::UNAUTHORIZED_EXTERNAL_SERVICE         => flags.push_str("UAEX"),
+                ResponseFlags::RATE_LIMIT_SERVICE_ERROR              => flags.push_str("RLSE"),
+                ResponseFlags::INVALID_ENVOY_REQUEST_HEADERS         => flags.push_str("IH"),
+                ResponseFlags::STREAM_IDLE_TIMEOUT                   => flags.push_str("SI"),
+                ResponseFlags::DOWNSTREAM_PROTOCOL_ERROR             => flags.push_str("DPE"),
+                ResponseFlags::UPSTREAM_PROTOCOL_ERROR               => flags.push_str("UPE"),
+                ResponseFlags::UPSTREAM_MAX_STREAM_DURATION_REACHED  => flags.push_str("UMSDR"),
+                ResponseFlags::RESPONSE_FROM_CACHE_FILTER            => flags.push_str("RFCF"),
+                ResponseFlags::NO_FILTER_CONFIG_FOUND                => flags.push_str("NFCF"),
+                ResponseFlags::OVERLOAD_MANAGER_TERMINATED           => flags.push_str("OM"),
+                ResponseFlags::DNS_RESOLUTION_FAILED                 => flags.push_str("DF"),
+                ResponseFlags::DROP_OVERLOAD                         => flags.push_str("DO"),
+                ResponseFlags::DOWNSTREAM_REMOTE_RESET               => flags.push_str("DR"),
+                ResponseFlags::UNCONDITIONAL_DROP_OVERLOAD           => flags.push_str("UDO"),
+                _ => flags.push_str("?"),
+            });
+
+            i += 1;
+        }
+
+        flags.finish()
+    }
+}
+
+impl<'a> ToSmolStr for ResponseFlagsLong<'a> {
+    fn to_smolstr(&self) -> SmolStr {
+        if self.0.is_empty() {
+            return SmolStr::new_static("-");
+        }
+        let mut flags = SmolStrBuilder::new();
+        let mut i = 0;
+
+        for f in self.0.clone() {
+            if i > 0 {
+                flags.push(',');
+            }
+            bitflags_match!(f, {
+                ResponseFlags::NO_HEALTHY_UPSTREAM                   => flags.push_str("NoHealthyUpstream"),
+                ResponseFlags::UPSTREAM_CONNECTION_FAILURE           => flags.push_str("UpstreamConnectionFailure"),
+                ResponseFlags::UPSTREAM_OVERFLOW                     => flags.push_str("UpstreamOverflow"),
+                ResponseFlags::NO_ROUTE_FOUND                        => flags.push_str("NoRouteFound"),
+                ResponseFlags::UPSTREAM_RETRY_LIMIT_EXCEEDED         => flags.push_str("UpstreamRetryLimitExceeded"),
+                ResponseFlags::NO_CLUSTER_FOUND                      => flags.push_str("NoClusterFound"),
+                ResponseFlags::DURATION_TIMEOUT                      => flags.push_str("DurationTimeout"),
+                ResponseFlags::DOWNSTREAM_CONNECTION_TERMINATION     => flags.push_str("DownstreamConnectionTermination"),
+                ResponseFlags::FAILED_LOCAL_HEALTH_CHECK             => flags.push_str("FailedLocalHealthCheck"),
+                ResponseFlags::UPSTREAM_REQUEST_TIMEOUT              => flags.push_str("UpstreamRequestTimeout"),
+                ResponseFlags::LOCAL_RESET                           => flags.push_str("LocalReset"),
+                ResponseFlags::UPSTREAM_REMOTE_RESET                 => flags.push_str("UpstreamRemoteReset"),
+                ResponseFlags::UPSTREAM_CONNECTION_TERMINATION       => flags.push_str("UpstreamConnectionTermination"),
+                ResponseFlags::DELAY_INJECTED                        => flags.push_str("DelayInjected"),
+                ResponseFlags::FAULT_INJECTED                        => flags.push_str("FaultInjected"),
+                ResponseFlags::RATE_LIMITED                          => flags.push_str("RateLimited"),
+                ResponseFlags::UNAUTHORIZED_EXTERNAL_SERVICE         => flags.push_str("UnauthorizedExternalService"),
+                ResponseFlags::RATE_LIMIT_SERVICE_ERROR              => flags.push_str("RateLimitServiceError"),
+                ResponseFlags::INVALID_ENVOY_REQUEST_HEADERS         => flags.push_str("InvalidEnvoyRequestHeaders"),
+                ResponseFlags::STREAM_IDLE_TIMEOUT                   => flags.push_str("StreamIdleTimeout"),
+                ResponseFlags::DOWNSTREAM_PROTOCOL_ERROR             => flags.push_str("DownstreamProtocolError"),
+                ResponseFlags::UPSTREAM_PROTOCOL_ERROR               => flags.push_str("UpstreamProtocolError"),
+                ResponseFlags::UPSTREAM_MAX_STREAM_DURATION_REACHED  => flags.push_str("UpstreamMaxStreamDurationReached"),
+                ResponseFlags::RESPONSE_FROM_CACHE_FILTER            => flags.push_str("ResponseFromCacheFilter"),
+                ResponseFlags::NO_FILTER_CONFIG_FOUND                => flags.push_str("NoFilterConfigFound"),
+                ResponseFlags::OVERLOAD_MANAGER_TERMINATED           => flags.push_str("OverloadManagerTerminated"),
+                ResponseFlags::DNS_RESOLUTION_FAILED                 => flags.push_str("DnsResolutionFailed"),
+                ResponseFlags::DROP_OVERLOAD                         => flags.push_str("DropOverload"),
+                ResponseFlags::DOWNSTREAM_REMOTE_RESET               => flags.push_str("DownstreamRemoteReset"),
+                ResponseFlags::UNCONDITIONAL_DROP_OVERLOAD           => flags.push_str("UnconditionalDropOverload"),
+                _ => flags.push_str("?"),
+            });
+
+            i += 1;
+        }
+
+        flags.finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_response_flags_short() {
+        let f = ResponseFlags::empty();
+        assert_eq!(ResponseFlagsShort(&f).to_smolstr(), SmolStr::new_static("-"));
+        let f = ResponseFlags::NO_ROUTE_FOUND;
+        assert_eq!(ResponseFlagsShort(&f).to_smolstr(), SmolStr::new_static("NR"));
+        let f = ResponseFlags::NO_HEALTHY_UPSTREAM | ResponseFlags::NO_ROUTE_FOUND;
+        assert_eq!(ResponseFlagsShort(&f).to_smolstr(), SmolStr::new_static("UH,NR"));
+    }
+
+    #[test]
+    fn test_response_flags_long() {
+        let f = ResponseFlags::empty();
+        assert_eq!(ResponseFlagsLong(&f).to_smolstr(), SmolStr::new_static("-"));
+        let f = ResponseFlags::NO_ROUTE_FOUND;
+        assert_eq!(ResponseFlagsLong(&f).to_smolstr(), SmolStr::new_static("NoRouteFound"));
+        let f = ResponseFlags::NO_HEALTHY_UPSTREAM | ResponseFlags::NO_ROUTE_FOUND;
+        assert_eq!(ResponseFlagsLong(&f).to_smolstr(), SmolStr::new_static("NoHealthyUpstream,NoRouteFound"));
+    }
+}

From 183bd1f4b75d0c0bd6a8d79e091fdf9540285336 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 20 May 2025 10:07:46 +0200
Subject: [PATCH 38/64] Miscellaneous Updates

- Renamed Token to Operator for improved semantic clarity.
- Updated Category and Operator to derive Serialize and Deserialize to meet orion-configuration requirements.
- Added a default implementation for LogFormatter.
- Improved debug behavior for unevaluated operators in non-debug builds.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml                    |  4 +-
 orion-format/src/context.rs                | 74 +++++++++---------
 orion-format/src/grammar.rs                | 88 +++++++++++-----------
 orion-format/src/lib.rs                    | 45 ++++++++---
 orion-format/src/{token.rs => operator.rs} | 32 ++++----
 5 files changed, 133 insertions(+), 110 deletions(-)
 rename orion-format/src/{token.rs => operator.rs} (85%)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index 613a0919..65a5c6db 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -13,12 +13,14 @@ thiserror.workspace = true
 criterion = "0.5.1"
 lazy_static = "1.5.0"
 ptrie = "0.7.2"
-smol_str = "0.3.2"
+smol_str = { version = "0.3.2", features = ["serde"] }
 chrono = "0.4.40"
 dhat = "0.3.3"
 bitflags = "2.9.0"
 itoa = "1.0.15"
 compact_str = "0.8.0"
+serde.workspace = true
+http-serde-ext = "1.0.2"
 
 [features]
 dhat-heap = []
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 86c0518e..7f201394 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -6,7 +6,7 @@ use http::{uri::Authority, HeaderName, Request, Response, Version};
 use smol_str::{SmolStr, SmolStrBuilder, ToSmolStr};
 
 use crate::{
-    token::{Category, Token},
+    operator::{Category, Operator},
     types::{ResponseFlags, ResponseFlagsShort},
     StringType,
 };
@@ -14,7 +14,7 @@ use crate::{
 const X_ENVOY_ORIGINAL_PATH: HeaderName = HeaderName::from_static("x-envoy-original-path");
 
 pub trait Context {
-    fn eval_part(&self, token: &Token) -> StringType;
+    fn eval_part(&self, op: &Operator) -> StringType;
     fn category() -> Category;
 }
 
@@ -41,11 +41,11 @@ pub struct DownstreamContext {}
 
 impl<'c> Context for UpstreamContext<'c> {
     fn category() -> Category {
-        Category::UPSTREAM_CONTEXT
+        Category::UpstreamContext
     }
-    fn eval_part<'a>(&'a self, token: &Token) -> StringType {
-        match token {
-            Token::UpstreamHost => StringType::Smol(SmolStr::new(self.authority.host())),
+    fn eval_part<'a>(&'a self, op: &Operator) -> StringType {
+        match op {
+            Operator::UpstreamHost => StringType::Smol(SmolStr::new(self.authority.host())),
             _ => StringType::None,
         }
     }
@@ -53,12 +53,12 @@ impl<'c> Context for UpstreamContext<'c> {
 
 impl Context for InitContext {
     fn category() -> Category {
-        Category::INIT_CONTEXT
+        Category::InitContext
     }
-    fn eval_part(&self, token: &Token) -> StringType {
-        match token {
-            // Token::StartTime => StringType::Compact(format_system_time_compact(self.start_time)),
-            Token::StartTime => StringType::Smol(format_system_time(self.start_time)),
+    fn eval_part(&self, op: &Operator) -> StringType {
+        match op {
+            // Operator::StartTime => StringType::Compact(format_system_time_compact(self.start_time)),
+            Operator::StartTime => StringType::Smol(format_system_time(self.start_time)),
             _ => StringType::None,
         }
     }
@@ -66,20 +66,20 @@ impl Context for InitContext {
 
 impl Context for FinishContext {
     fn category() -> Category {
-        Category::FINISH_CONTEXT
+        Category::FinishContext
     }
-    fn eval_part(&self, token: &Token) -> StringType {
-        match token {
-            Token::ResponseFlags => StringType::Smol(ResponseFlagsShort(&self.response_flags).to_smolstr()),
-            Token::Duration => {
+    fn eval_part(&self, op: &Operator) -> StringType {
+        match op {
+            Operator::ResponseFlags => StringType::Smol(ResponseFlagsShort(&self.response_flags).to_smolstr()),
+            Operator::Duration => {
                 let mut buffer = itoa::Buffer::new();
                 StringType::Smol(SmolStr::new(buffer.format(self.duration.as_millis())))
             },
-            Token::BytesReceived => {
+            Operator::BytesReceived => {
                 let mut buffer = itoa::Buffer::new();
                 StringType::Smol(SmolStr::new(buffer.format(self.bytes_received)))
             },
-            Token::BytesSent => {
+            Operator::BytesSent => {
                 let mut buffer = itoa::Buffer::new();
                 StringType::Smol(SmolStr::new(buffer.format(self.bytes_sent)))
             },
@@ -95,12 +95,12 @@ pub struct UpstreamResponse<'a, T>(pub &'a Response<T>);
 
 impl<'a, T> Context for DownstreamRequest<'a, T> {
     fn category() -> Category {
-        Category::DOWNSTREAM_REQUEST
+        Category::DownstreamRequest
     }
-    fn eval_part(&self, token: &Token) -> StringType {
-        match token {
-            Token::RequestPath => StringType::Smol(SmolStr::new(self.0.uri().path())),
-            Token::RequestOriginalPathOrPath => {
+    fn eval_part(&self, op: &Operator) -> StringType {
+        match op {
+            Operator::RequestPath => StringType::Smol(SmolStr::new(self.0.uri().path())),
+            Operator::RequestOriginalPathOrPath => {
                 let path_str = self
                     .0
                     .headers()
@@ -110,15 +110,15 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
 
                 StringType::Smol(SmolStr::new(path_str))
             },
-            Token::RequestAuthority => {
+            Operator::RequestAuthority => {
                 if let Some(a) = self.0.uri().authority() {
                     StringType::Smol(SmolStr::new(a.host()))
                 } else {
                     StringType::None
                 }
             },
-            Token::RequestMethod => StringType::Smol(SmolStr::new(self.0.method().as_str())),
-            Token::RequestScheme => {
+            Operator::RequestMethod => StringType::Smol(SmolStr::new(self.0.method().as_str())),
+            Operator::RequestScheme => {
                 if let Some(s) = self.0.uri().scheme() {
                     StringType::Smol(SmolStr::new(s.as_str()))
                 } else {
@@ -126,7 +126,7 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
                 }
             },
 
-            Token::RequestStandard(h) => {
+            Operator::RequestStandard(h) => {
                 let hv = self.0.headers().get(h);
                 match hv {
                     Some(hv) => {
@@ -139,7 +139,7 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
                     None => StringType::Smol(SmolStr::new_static("")),
                 }
             },
-            Token::Protocol => StringType::Smol(SmolStr::new_static(into_protocol(self.0.version()))),
+            Operator::Protocol => StringType::Smol(SmolStr::new_static(into_protocol(self.0.version()))),
             _ => StringType::None,
         }
     }
@@ -147,11 +147,11 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
 
 impl<'a, T> Context for UpstreamRequest<'a, T> {
     fn category() -> Category {
-        Category::UPSTREAM_REQUEST
+        Category::UpstreamRequest
     }
-    fn eval_part(&self, token: &Token) -> StringType {
-        match token {
-            Token::UpstreamProtocol => StringType::Smol(SmolStr::new_static(into_protocol(self.0.version()))),
+    fn eval_part(&self, op: &Operator) -> StringType {
+        match op {
+            Operator::UpstreamProtocol => StringType::Smol(SmolStr::new_static(into_protocol(self.0.version()))),
             _ => StringType::None,
         }
     }
@@ -159,12 +159,12 @@ impl<'a, T> Context for UpstreamRequest<'a, T> {
 
 impl<'a, T> Context for DownstreamResponse<'a, T> {
     fn category() -> Category {
-        Category::DOWNSTREAM_RESPONSE
+        Category::DownstreamResponse
     }
-    fn eval_part(&self, token: &Token) -> StringType {
-        match token {
-            Token::ResponseCode => StringType::Smol(SmolStr::new_inline(self.0.status().as_str())),
-            Token::ResponseStandard(h) => {
+    fn eval_part(&self, op: &Operator) -> StringType {
+        match op {
+            Operator::ResponseCode => StringType::Smol(SmolStr::new_inline(self.0.status().as_str())),
+            Operator::ResponseStandard(h) => {
                 let hv = self.0.headers().get(h.as_str());
                 match hv {
                     Some(hv) => {
diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index 109d0900..e852d43b 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -1,4 +1,4 @@
-use crate::token::{Category, Token};
+use crate::operator::{Category, Operator};
 use crate::{FormatError, Grammar, Template};
 use http::HeaderName;
 use lazy_static::lazy_static;
@@ -14,22 +14,22 @@ macro_rules! trie_mapstr {
 }
 
 lazy_static! {
-    static ref ENVOY_REQ_ARGS: Trie<u8, (Token, Category, usize, bool)> = {
+    static ref ENVOY_REQ_ARGS: Trie<u8, (Operator, Category, usize, bool)> = {
         let mut trie = Trie::new();
-        trie_mapstr!(trie, ":SCHEME",Token::RequestScheme, Category::ARGUMENT);
-        trie_mapstr!(trie, ":METHOD",Token::RequestMethod, Category::ARGUMENT);
-        trie_mapstr!(trie, ":PATH", Token::RequestPath, Category::ARGUMENT);
-        trie_mapstr!(trie, ":AUTHORITY", Token::RequestAuthority, Category::ARGUMENT);
-        trie_mapstr!(trie, "X-ENVOY-ORIGINAL-PATH?:PATH", Token::RequestOriginalPathOrPath, Category::ARGUMENT);
+        trie_mapstr!(trie, ":SCHEME",Operator::RequestScheme, Category::Argument);
+        trie_mapstr!(trie, ":METHOD",Operator::RequestMethod, Category::Argument);
+        trie_mapstr!(trie, ":PATH", Operator::RequestPath, Category::Argument);
+        trie_mapstr!(trie, ":AUTHORITY", Operator::RequestAuthority, Category::Argument);
+        trie_mapstr!(trie, "X-ENVOY-ORIGINAL-PATH?:PATH", Operator::RequestOriginalPathOrPath, Category::Argument);
         trie
     };
 
-    static ref ENVOY_RESP_ARGS: Trie<u8, (Token, Category, usize, bool)> = {
+    static ref ENVOY_RESP_ARGS: Trie<u8, (Operator, Category, usize, bool)> = {
         let trie = Trie::new();
         trie
     };
 
-    static ref ENVOY_PATTERNS: Trie<u8, (Token, Category, usize, bool)> = {
+    static ref ENVOY_PATTERNS: Trie<u8, (Operator, Category, usize, bool)> = {
         let mut trie = Trie::new();
         // trie_mapstr!(trie, "REQUEST_DURATION", Token::RequestDuration);
         // trie_mapstr!(trie, "REQUEST_TX_DURATION", Token::RequestTxDuration);
@@ -37,31 +37,31 @@ lazy_static! {
         // trie_mapstr!(trie, "RESPONSE_TX_DURATION", Token::ResponseTxDuration);
         // trie_mapstr!(trie, "DOWNSTREAM_HANDSHAKE_DURATION", Token::DownstreamHandshakeDuration);
         // trie_mapstr!(trie, "ROUNDTRIP_DURATION", Token::RoundtripDuration);
-        trie_mapstr!(trie, "BYTES_RECEIVED", Token::BytesReceived, Category::FINISH_CONTEXT);
+        trie_mapstr!(trie, "BYTES_RECEIVED", Operator::BytesReceived, Category::FinishContext);
         // trie_mapstr!(trie, "BYTES_RETRANSMITTED", Token::BytesRetransmitted);
         // trie_mapstr!(trie, "PACKETS_RETRANSMITTED", Token::PacketsRetransmitted);
         // trie_mapstr!(trie, "UPSTREAM_WIRE_BYTES_RECEIVED", Token::UpstreamWireBytesReceived);
         // trie_mapstr!(trie, "UPSTREAM_HEADER_BYTES_RECEIVED", Token::UpstreamHeaderBytesReceived);
         // trie_mapstr!(trie, "DOWNSTREAM_WIRE_BYTES_RECEIVED", Token::DownstreamWireBytesReceived);
         // trie_mapstr!(trie, "DOWNSTREAM_HEADER_BYTES_RECEIVED", Token::DownstreamHeaderBytesReceived);
-        trie_mapstr!(trie, "PROTOCOL", Token::Protocol, Category::DOWNSTREAM_REQUEST);
-        trie_mapstr!(trie, "UPSTREAM_PROTOCOL", Token::UpstreamProtocol, Category::UPSTREAM_REQUEST);
-        trie_mapstr!(trie, "RESPONSE_CODE", Token::ResponseCode, Category::DOWNSTREAM_RESPONSE);
+        trie_mapstr!(trie, "PROTOCOL", Operator::Protocol, Category::DownstreamRequest);
+        trie_mapstr!(trie, "UPSTREAM_PROTOCOL", Operator::UpstreamProtocol, Category::UpstreamRequest);
+        trie_mapstr!(trie, "RESPONSE_CODE", Operator::ResponseCode, Category::DownstreamResponse);
         // trie_mapstr!(trie, "RESPONSE_CODE_DETAILS", Token::ResponseCodeDetails);
         // trie_mapstr!(trie, "CONNECTION_TERMINATION_DETAILS", Token::ConnectionTerminationDetails);
-        trie_mapstr!(trie, "BYTES_SENT", Token::BytesSent, Category::FINISH_CONTEXT);
+        trie_mapstr!(trie, "BYTES_SENT", Operator::BytesSent, Category::FinishContext);
         // trie_mapstr!(trie, "UPSTREAM_WIRE_BYTES_SENT", Token::UpstreamWireBytesSent);
         // trie_mapstr!(trie, "UPSTREAM_HEADER_BYTES_SENT", Token::UpstreamHeaderBytesSent);
         // trie_mapstr!(trie, "DOWNSTREAM_WIRE_BYTES_SENT", Token::DownstreamWireBytesSent);
         // trie_mapstr!(trie, "DOWNSTREAM_HEADER_BYTES_SENT", Token::DownstreamHeaderBytesSent);
-        trie_mapstr!(trie, "DURATION", Token::Duration, Category::FINISH_CONTEXT);
+        trie_mapstr!(trie, "DURATION", Operator::Duration, Category::FinishContext);
         // trie_mapstr!(trie, "COMMON_DURATION", Token::CommonDuration);
         // trie_mapstr!(trie, "CUSTOM_FLAGS", Token::CustomFlags);
-        trie_mapstr!(trie, "RESPONSE_FLAGS", Token::ResponseFlags, Category::FINISH_CONTEXT);
+        trie_mapstr!(trie, "RESPONSE_FLAGS", Operator::ResponseFlags, Category::FinishContext);
         // trie_mapstr!(trie, "RESPONSE_FLAGS_LONG", Token::ResponseFlagsLong);
         // trie_mapstr!(trie, "UPSTREAM_HOST_NAME", Token::UpstreamHostName);
         // trie_mapstr!(trie, "UPSTREAM_HOST_NAME_WITHOUT_PORT", Token::UpstreamHostNameWithoutPort);
-        trie_mapstr!(trie, "UPSTREAM_HOST", Token::UpstreamHost, Category::UPSTREAM_CONTEXT);
+        trie_mapstr!(trie, "UPSTREAM_HOST", Operator::UpstreamHost, Category::UpstreamContext);
         // trie_mapstr!(trie, "UPSTREAM_CONNECTION_ID", Token::UpstreamConnectionId);
         // trie_mapstr!(trie, "UPSTREAM_CLUSTER", Token::UpstreamCluster);
         // trie_mapstr!(trie, "UPSTREAM_CLUSTER_RAW", Token::UpstreamClusterRaw);
@@ -130,7 +130,7 @@ lazy_static! {
         // trie_mapstr!(trie, "TLS_JA3_FINGERPRINT", Token::TlsJa3Fingerprint);
         // trie_mapstr!(trie, "UNIQUE_ID", Token::UniqueId);
         // trie_mapstr!(trie, "STREAM_ID", Token::StreamId);
-        trie_mapstr!(trie, "START_TIME", Token::StartTime, Category::INIT_CONTEXT);
+        trie_mapstr!(trie, "START_TIME", Operator::StartTime, Category::InitContext);
         // trie_mapstr!(trie, "START_TIME_LOCAL", Token::StartTimeLocal);
         // trie_mapstr!(trie, "EMIT_TIME", Token::EmitTime);
         // trie_mapstr!(trie, "EMIT_TIME_LOCAL", Token::EmitTimeLocal);
@@ -145,8 +145,8 @@ lazy_static! {
         // trie_mapstr!(trie, "UPSTREAM_PEER_CERT_V_END", Token::UpstreamPeerCertVEnd);
         // trie_mapstr!(trie, "ENVIRONMENT", Token::Environment);
         // trie_mapstr!(trie, "UPSTREAM_CONNECTION_POOL_READY_DURATION", Token::UpstreamConnectionPoolReadyDuration);
-        trie_mapstr!(trie, "REQ", Token::Request, Category::DOWNSTREAM_REQUEST, true); // %REQ(USER-AGENT)%
-        trie_mapstr!(trie, "RESP", Token::Response, Category::DOWNSTREAM_RESPONSE, true); // %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)%
+        trie_mapstr!(trie, "REQ", Operator::Request, Category::DownstreamRequest, true); // %REQ(USER-AGENT)%
+        trie_mapstr!(trie, "RESP", Operator::Response, Category::DownstreamResponse, true); // %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)%
         trie
     };
 }
@@ -154,29 +154,29 @@ lazy_static! {
 pub struct EnvoyGrammar;
 
 impl EnvoyGrammar {
-    fn parse_request(arg: &str) -> Result<Token, FormatError> {
+    fn parse_request(arg: &str) -> Result<Operator, FormatError> {
         match ENVOY_REQ_ARGS.find_longest_prefix(arg.bytes()) {
             Some((t, _, _, _)) => Ok(t.clone()),
             None => {
                 let name =
                     HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidRequestArg(arg.into()))?;
-                Ok(Token::RequestStandard(name))
+                Ok(Operator::RequestStandard(name))
             },
         }
     }
 
-    fn parse_response(arg: &str) -> Result<Token, FormatError> {
+    fn parse_response(arg: &str) -> Result<Operator, FormatError> {
         match ENVOY_RESP_ARGS.find_longest_prefix(arg.bytes()) {
             Some((t, _, _, _)) => Ok(t.clone()),
             None => {
                 let name =
                     HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidResponseArg(arg.into()))?;
-                Ok(Token::ResponseStandard(name))
+                Ok(Operator::ResponseStandard(name))
             },
         }
     }
 
-    fn extract_token_arg(input: &str) -> Result<(&str, usize), FormatError> {
+    fn extract_operator_arg(input: &str) -> Result<(&str, usize), FormatError> {
         if let Some(rest) = input.strip_prefix('(') {
             if let Some(end) = rest.find(')') {
                 let arg = &rest[..end];
@@ -198,7 +198,7 @@ impl Grammar for EnvoyGrammar {
         let mut i = 0;
 
         while i < input.len() {
-            let mut longest_placeholder: Option<(Token, Category, usize)> = None;
+            let mut longest_placeholder: Option<(Operator, Category, usize)> = None;
             let mut skip = None;
 
             // finst the longest placeholder starting from the current index i
@@ -213,15 +213,15 @@ impl Grammar for EnvoyGrammar {
                     let after_placeholder = &remainder[*placeholder_len..];
                     // placeholder found
                     if *has_arg {
-                        let (arg_value, arg_len) = Self::extract_token_arg(after_placeholder)?;
+                        let (arg_value, arg_len) = Self::extract_operator_arg(after_placeholder)?;
 
                         if longest_placeholder.is_none() || *placeholder_len > longest_placeholder.as_ref().unwrap().2 {
                             match placeholder {
-                                Token::Request => {
+                                Operator::Request => {
                                     let token = Self::parse_request(arg_value)?;
                                     longest_placeholder = Some((token, *category, *placeholder_len));
                                 },
-                                Token::Response => {
+                                Operator::Response => {
                                     let token = Self::parse_response(arg_value)?;
                                     longest_placeholder = Some((token, *category, *placeholder_len));
                                 },
@@ -291,6 +291,8 @@ impl Grammar for EnvoyGrammar {
 // Unit tests module
 #[cfg(test)]
 mod tests {
+    use crate::DEFAULT_ENVOY_FORMAT;
+
     use super::*;
 
     #[test]
@@ -305,8 +307,8 @@ mod tests {
     fn test_parse_only_placeholders() {
         let input = "%START_TIME%%PROTOCOL%";
         let expected = vec![
-            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT),
-            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
+            Template::Placeholder(Operator::StartTime, Category::InitContext),
+            Template::Placeholder(Operator::Protocol, Category::DownstreamRequest),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
@@ -317,9 +319,9 @@ mod tests {
         let input = "Start %REQ(:METHOD)% middle %PROTOCOL% end.";
         let expected = vec![
             Template::Literal("Start ".into()),
-            Template::Placeholder(Token::RequestMethod, Category::DOWNSTREAM_REQUEST),
+            Template::Placeholder(Operator::RequestMethod, Category::DownstreamRequest),
             Template::Literal(" middle ".into()),
-            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
+            Template::Placeholder(Operator::Protocol, Category::DownstreamRequest),
             Template::Literal(" end.".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
@@ -330,7 +332,7 @@ mod tests {
     fn test_parse_starts_with_placeholder() {
         let input = "%START_TIME% literal after.";
         let expected = vec![
-            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT),
+            Template::Placeholder(Operator::StartTime, Category::InitContext),
             Template::Literal(" literal after.".into()),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
@@ -342,7 +344,7 @@ mod tests {
         let input = "Literal before %PROTOCOL%";
         let expected = vec![
             Template::Literal("Literal before ".into()),
-            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
+            Template::Placeholder(Operator::Protocol, Category::DownstreamRequest),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
         assert_eq!(actual, expected);
@@ -369,13 +371,13 @@ mod tests {
         let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(:PATH)% %PROTOCOL%""#;
         let expected = vec![
             Template::Char('['),
-            Template::Placeholder(Token::StartTime, Category::INIT_CONTEXT),
+            Template::Placeholder(Operator::StartTime, Category::InitContext),
             Template::Literal("] \"".into()),
-            Template::Placeholder(Token::RequestMethod, Category::DOWNSTREAM_REQUEST),
+            Template::Placeholder(Operator::RequestMethod, Category::DownstreamRequest),
             Template::Char(' '),
-            Template::Placeholder(Token::RequestPath, Category::DOWNSTREAM_REQUEST),
+            Template::Placeholder(Operator::RequestPath, Category::DownstreamRequest),
             Template::Char(' '),
-            Template::Placeholder(Token::Protocol, Category::DOWNSTREAM_REQUEST),
+            Template::Placeholder(Operator::Protocol, Category::DownstreamRequest),
             Template::Char('"'),
         ];
         let actual = EnvoyGrammar::parse(input).unwrap();
@@ -384,17 +386,13 @@ mod tests {
 
     #[test]
     fn test_default_fmt() {
-        let input = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%"
-            %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION%
-            %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%"
-            "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
-        _ = EnvoyGrammar::parse(input).unwrap();
+        _ = EnvoyGrammar::parse(DEFAULT_ENVOY_FORMAT).unwrap();
     }
 
     // bad patters..
 
     #[test]
-    fn test_parse_unsupported_token() {
+    fn test_parse_unsupported_operator() {
         let input = "%UNSUPPORTED%";
         let result = EnvoyGrammar::parse(input);
         assert!(matches!(result, Err(FormatError::UnsupportedPattern(_))));
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 59697072..2c6b0034 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -1,16 +1,17 @@
 pub mod context;
 pub mod grammar;
-pub mod token;
+pub mod operator;
 pub mod types;
 
 // use compact_str::CompactString;
 use context::Context;
+use operator::{Category, Operator};
+use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
 use std::fmt::{self, Display, Formatter, Write};
 use std::io::Write as IoWrite;
 use std::sync::Arc;
 use thiserror::Error;
-use token::{Category, Token};
 
 use crate::grammar::EnvoyGrammar;
 
@@ -34,14 +35,14 @@ pub enum FormatError {
     InvalidResponseArg(String),
 }
 
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub enum Template {
     Char(char),
     Literal(SmolStr),
-    Placeholder(Token, Category), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
+    Placeholder(Operator, Category), // eg. ("DURATION", Pattern::Duration, None), (Pattern::Req, Some(":METHOD"))
 }
 
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub enum StringType {
     Char(char),
     Smol(SmolStr),
@@ -49,12 +50,18 @@ pub enum StringType {
     None,
 }
 
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub struct LogFormatter {
     pub template: Arc<Vec<Template>>,
     pub format: Vec<StringType>,
 }
 
+impl Default for LogFormatter {
+    fn default() -> Self {
+        LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap()
+    }
+}
+
 impl LogFormatter {
     pub fn try_new(input: &str) -> Result<LogFormatter, FormatError> {
         let template = EnvoyGrammar::parse(input)?;
@@ -74,9 +81,9 @@ impl LogFormatter {
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
         let context_category = C::category();
         for (part, out) in self.template.iter().zip(&mut self.format.iter_mut()) {
-            if let Template::Placeholder(token, categories) = part {
-                if categories.contains(context_category) {
-                    *out = ctx.eval_part(token);
+            if let Template::Placeholder(op, category) = part {
+                if *category == context_category {
+                    *out = ctx.eval_part(op);
                 }
             }
         }
@@ -86,7 +93,7 @@ impl LogFormatter {
 
     pub fn write_to<W: std::io::Write>(&self, w: &mut W) -> std::io::Result<usize> {
         let mut total_bytes = 0;
-        for (part, out) in self.template.iter().zip(self.format.iter()) {
+        for (_part, out) in self.template.iter().zip(self.format.iter()) {
             total_bytes += match out {
                 StringType::Smol(s) => IoWrite::write(w, s.as_bytes())?,
                 StringType::Char(c) => {
@@ -95,12 +102,20 @@ impl LogFormatter {
                     IoWrite::write(w, bytes)?
                 },
                 // StringType::Compact(s) => IoWrite::write(w, s.as_bytes())?,
-                _ => IoWrite::write(w, format!("%{:?}%", part).as_bytes())?,
+                #[cfg(debug_assertions)]
+                _ => IoWrite::write(w, format!("%{:?}%", _part).as_bytes())?,
+                #[cfg(not(debug_assertions))]
+                _ => IoWrite::write(w, "?".as_bytes())?,
             };
         }
 
         Ok(total_bytes)
     }
+
+    #[inline]
+    pub fn is_fully_formatted(&self) -> bool {
+        self.format.iter().all(|f| *f != StringType::None)
+    }
 }
 
 impl Display for LogFormatter {
@@ -234,6 +249,13 @@ mod tests {
         assert_eq!(actual, expected);
     }
 
+    #[test]
+    fn test_unevaluated_operator() {
+        let formatter = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
+        let actual = format!("{}", &formatter);
+        println!("{actual}");
+    }
+
     #[test]
     fn default_format_string() {
         let req = build_request();
@@ -249,6 +271,7 @@ mod tests {
             bytes_sent: 256,
             response_flags: ResponseFlags::NO_HEALTHY_UPSTREAM,
         });
+        assert!(formatter.is_fully_formatted());
         println!("{}", &formatter);
     }
 }
diff --git a/orion-format/src/token.rs b/orion-format/src/operator.rs
similarity index 85%
rename from orion-format/src/token.rs
rename to orion-format/src/operator.rs
index 9bef89a4..d339162a 100644
--- a/orion-format/src/token.rs
+++ b/orion-format/src/operator.rs
@@ -1,23 +1,21 @@
-use bitflags::bitflags;
 use http::HeaderName;
+use serde::{Deserialize, Serialize};
 
-bitflags! {
-    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub struct Category: u16 {
-        const INIT_CONTEXT = 1;
-        const FINISH_CONTEXT = 1 << 1;
-        const UPSTREAM_CONTEXT = 1 << 2;
-        const DOWNSTREAM_CONTEXT = 1 << 3;
-        const DOWNSTREAM_REQUEST = 1 << 4;
-        const DOWNSTREAM_RESPONSE = 1 << 5;
-        const UPSTREAM_REQUEST = 1 << 6;
-        const UPSTREAM_RESPONSE = 1 << 7;
-        const ARGUMENT = 1 << 8;
-    }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Category {
+    InitContext,
+    FinishContext,
+    UpstreamContext,
+    DownstreamContext,
+    DownstreamRequest,
+    DownstreamResponse,
+    UpstreamRequest,
+    UpstreamResponse,
+    Argument,
 }
 
-#[derive(Clone, PartialEq, Hash, Debug)]
-pub enum Token {
+#[derive(Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
+pub enum Operator {
     RequestDuration,
     RequestTxDuration,
     ResponseDuration,
@@ -138,7 +136,9 @@ pub enum Token {
     RequestPath,
     RequestOriginalPathOrPath,
     RequestAuthority,
+    #[serde(with = "http_serde_ext::header_name")]
     RequestStandard(HeaderName),
     Response, // placeholder
+    #[serde(with = "http_serde_ext::header_name")]
     ResponseStandard(HeaderName),
 }

From 824db7a922a140fd8776870768e7ec6068e67016 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 20 May 2025 17:11:11 +0200
Subject: [PATCH 39/64] Refactor error handling for format parsing

- Replace `UnsupportedPattern` with `InvalidOperator` for clarity
- Improve error messages for consistency and readability

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/grammar.rs | 10 ++++++----
 orion-format/src/lib.rs     | 16 ++++++++--------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index e852d43b..fb6c50b1 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -230,19 +230,21 @@ impl Grammar for EnvoyGrammar {
                         }
 
                         if !after_placeholder[arg_len..].starts_with('%') {
-                            return Err(FormatError::MissingDelimiter(remainder.into()));
+                            return Err(FormatError::MissingDelimiter(remainder[..*placeholder_len].into()));
                         }
 
                         skip = Some(2 + *placeholder_len + arg_len);
                     } else {
                         longest_placeholder = Some((placeholder.clone(), *category, *placeholder_len));
                         if !after_placeholder.starts_with('%') {
-                            return Err(FormatError::MissingDelimiter(remainder.into()));
+                            return Err(FormatError::MissingDelimiter(remainder[..*placeholder_len].into()));
                         }
                         skip = Some(2 + *placeholder_len);
                     }
                 } else {
-                    return Err(FormatError::UnsupportedPattern(remainder.into()));
+                    return Err(FormatError::InvalidOperator(
+                        remainder.split_once('%').map(|(operator, _)| operator).unwrap_or(remainder).into(),
+                    ));
                 }
             }
 
@@ -395,7 +397,7 @@ mod tests {
     fn test_parse_unsupported_operator() {
         let input = "%UNSUPPORTED%";
         let result = EnvoyGrammar::parse(input);
-        assert!(matches!(result, Err(FormatError::UnsupportedPattern(_))));
+        assert!(matches!(result, Err(FormatError::InvalidOperator(_))));
     }
 
     #[test]
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 2c6b0034..b48e5048 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -19,19 +19,19 @@ pub const DEFAULT_ENVOY_FORMAT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-
 
 #[derive(Error, Debug)]
 pub enum FormatError {
-    #[error("pattern `{0}` not supported")]
-    UnsupportedPattern(String),
-    #[error("missing argument for `{0}`")]
+    #[error("invalid operator `{0}`")]
+    InvalidOperator(String),
+    #[error("missing argument `{0}`")]
     MissingArgument(String),
-    #[error("missing braket around `{0}`...")]
+    #[error("missing braket `{0}`")]
     MissingBracket(String),
-    #[error("missing delimiter around `{0}`...")]
+    #[error("missing delimiter `{0}`")]
     MissingDelimiter(String),
-    #[error("empty argument around `{0}`...")]
+    #[error("empty argument `{0}`")]
     EmptyArgument(String),
-    #[error("invalid request argument (`{0}`)")]
+    #[error("invalid request argument `{0}`")]
     InvalidRequestArg(String),
-    #[error("invalid response argument (`{0}`)")]
+    #[error("invalid response argument `{0}`")]
     InvalidResponseArg(String),
 }
 

From 75255e81bd1e08107c4491e986e67c0d1cd8de4d Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Wed, 21 May 2025 06:54:22 +0200
Subject: [PATCH 40/64] Performance improvements.

- Introduced IndexedTemplate struct to optimize template handling.
- Replaced template field with catalog in LogFormatter.
- Added strum and strum_macros dependencies for EnumCount.
```

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml      |  2 ++
 orion-format/src/lib.rs      | 42 ++++++++++++++++++++++++------------
 orion-format/src/operator.rs |  4 +++-
 3 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index 65a5c6db..db577712 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -21,6 +21,8 @@ itoa = "1.0.15"
 compact_str = "0.8.0"
 serde.workspace = true
 http-serde-ext = "1.0.2"
+strum = { version = "0.27.1", features = ["derive"] }
+strum_macros = "0.27.1"
 
 [features]
 dhat-heap = []
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index b48e5048..2af08384 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -11,11 +11,12 @@ use smol_str::SmolStr;
 use std::fmt::{self, Display, Formatter, Write};
 use std::io::Write as IoWrite;
 use std::sync::Arc;
+use strum::EnumCount;
 use thiserror::Error;
 
 use crate::grammar::EnvoyGrammar;
 
-pub const DEFAULT_ENVOY_FORMAT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+pub const DEFAULT_ENVOY_FORMAT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%"\n"#;
 
 #[derive(Error, Debug)]
 pub enum FormatError {
@@ -50,10 +51,16 @@ pub enum StringType {
     None,
 }
 
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
+struct IndexedTemplate {
+    templates: Vec<Template>,
+    indices: [Vec<u8>; Category::COUNT],
+}
+
 #[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub struct LogFormatter {
-    pub template: Arc<Vec<Template>>,
-    pub format: Vec<StringType>,
+    catalog: Arc<IndexedTemplate>,
+    format: Vec<StringType>,
 }
 
 impl Default for LogFormatter {
@@ -64,10 +71,18 @@ impl Default for LogFormatter {
 
 impl LogFormatter {
     pub fn try_new(input: &str) -> Result<LogFormatter, FormatError> {
-        let template = EnvoyGrammar::parse(input)?;
-        let mut format: Vec<StringType> = Vec::with_capacity(template.len());
+        let templates = EnvoyGrammar::parse(input)?;
+        let mut indices: [Vec<u8>; Category::COUNT] = std::array::from_fn(|_| vec![]);
+
+        for (i, part) in templates.iter().enumerate() {
+            if let Template::Placeholder(_, category) = part {
+                indices[*category as usize].push(i as u8);
+            }
+        }
+
+        let mut format: Vec<StringType> = Vec::with_capacity(templates.len());
 
-        for t in template.iter() {
+        for t in templates.iter() {
             match t {
                 Template::Char(c) => format.push(StringType::Char(*c)),
                 Template::Literal(smol_str) => format.push(StringType::Smol(smol_str.clone())),
@@ -75,15 +90,14 @@ impl LogFormatter {
             }
         }
 
-        Ok(LogFormatter { template: Arc::new(template), format })
+        Ok(LogFormatter { catalog: Arc::new(IndexedTemplate { templates, indices }), format })
     }
 
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
-        let context_category = C::category();
-        for (part, out) in self.template.iter().zip(&mut self.format.iter_mut()) {
-            if let Template::Placeholder(op, category) = part {
-                if *category == context_category {
-                    *out = ctx.eval_part(op);
+        for idx in &self.catalog.indices[C::category() as usize] {
+            unsafe {
+                if let Template::Placeholder(op, _) = self.catalog.templates.get_unchecked(*idx as usize) {
+                    *self.format.get_unchecked_mut(*idx as usize) = ctx.eval_part(&op);
                 }
             }
         }
@@ -93,7 +107,7 @@ impl LogFormatter {
 
     pub fn write_to<W: std::io::Write>(&self, w: &mut W) -> std::io::Result<usize> {
         let mut total_bytes = 0;
-        for (_part, out) in self.template.iter().zip(self.format.iter()) {
+        for (_part, out) in self.catalog.templates.iter().zip(self.format.iter()) {
             total_bytes += match out {
                 StringType::Smol(s) => IoWrite::write(w, s.as_bytes())?,
                 StringType::Char(c) => {
@@ -120,7 +134,7 @@ impl LogFormatter {
 
 impl Display for LogFormatter {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        for (part, out) in self.template.iter().zip(self.format.iter()) {
+        for (part, out) in self.catalog.templates.iter().zip(self.format.iter()) {
             match out {
                 StringType::Smol(s) => f.write_str(s.as_ref())?,
                 StringType::Char(c) => f.write_char(*c)?,
diff --git a/orion-format/src/operator.rs b/orion-format/src/operator.rs
index d339162a..5de41ad0 100644
--- a/orion-format/src/operator.rs
+++ b/orion-format/src/operator.rs
@@ -1,7 +1,9 @@
 use http::HeaderName;
 use serde::{Deserialize, Serialize};
+use strum_macros::EnumCount;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, EnumCount)]
+#[repr(usize)]
 pub enum Category {
     InitContext,
     FinishContext,

From 46ba212e7de71c516eb3959d3d15c7860c29922e Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Wed, 21 May 2025 10:19:57 +0200
Subject: [PATCH 41/64] Replace mutable references with RefCell to allow
 interior mutability for the `format` field. This provides better
 integrability.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/lib.rs | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 2af08384..f2861076 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -8,6 +8,7 @@ use context::Context;
 use operator::{Category, Operator};
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
+use std::cell::RefCell;
 use std::fmt::{self, Display, Formatter, Write};
 use std::io::Write as IoWrite;
 use std::sync::Arc;
@@ -60,7 +61,7 @@ struct IndexedTemplate {
 #[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub struct LogFormatter {
     catalog: Arc<IndexedTemplate>,
-    format: Vec<StringType>,
+    format: RefCell<Vec<StringType>>,
 }
 
 impl Default for LogFormatter {
@@ -90,14 +91,14 @@ impl LogFormatter {
             }
         }
 
-        Ok(LogFormatter { catalog: Arc::new(IndexedTemplate { templates, indices }), format })
+        Ok(LogFormatter { catalog: Arc::new(IndexedTemplate { templates, indices }), format: RefCell::new(format) })
     }
 
-    pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &mut Self {
+    pub fn with_context<'a, C: Context>(&self, ctx: &'a C) -> &Self {
         for idx in &self.catalog.indices[C::category() as usize] {
             unsafe {
                 if let Template::Placeholder(op, _) = self.catalog.templates.get_unchecked(*idx as usize) {
-                    *self.format.get_unchecked_mut(*idx as usize) = ctx.eval_part(&op);
+                    *self.format.borrow_mut().get_unchecked_mut(*idx as usize) = ctx.eval_part(&op);
                 }
             }
         }
@@ -107,7 +108,7 @@ impl LogFormatter {
 
     pub fn write_to<W: std::io::Write>(&self, w: &mut W) -> std::io::Result<usize> {
         let mut total_bytes = 0;
-        for (_part, out) in self.catalog.templates.iter().zip(self.format.iter()) {
+        for (_part, out) in self.catalog.templates.iter().zip(self.format.borrow().iter()) {
             total_bytes += match out {
                 StringType::Smol(s) => IoWrite::write(w, s.as_bytes())?,
                 StringType::Char(c) => {
@@ -128,13 +129,13 @@ impl LogFormatter {
 
     #[inline]
     pub fn is_fully_formatted(&self) -> bool {
-        self.format.iter().all(|f| *f != StringType::None)
+        self.format.borrow().iter().all(|f| *f != StringType::None)
     }
 }
 
 impl Display for LogFormatter {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        for (part, out) in self.catalog.templates.iter().zip(self.format.iter()) {
+        for (part, out) in self.catalog.templates.iter().zip(self.format.borrow().iter()) {
             match out {
                 StringType::Smol(s) => f.write_str(s.as_ref())?,
                 StringType::Char(c) => f.write_char(*c)?,
@@ -179,7 +180,7 @@ mod tests {
         let mut req = build_request();
         req.headers_mut().append("X-ENVOY-ORIGINAL-PATH", HeaderValue::from_static("/original"));
 
-        let mut formatter = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
+        let formatter = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
         let expected = "/";
 
         formatter.with_context(&DownstreamRequest(&req));
@@ -192,7 +193,7 @@ mod tests {
         let mut req = build_request();
         req.headers_mut().append("X-ENVOY-ORIGINAL-PATH", HeaderValue::from_static("/original"));
 
-        let mut formatter = LogFormatter::try_new("%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)%").unwrap();
+        let formatter = LogFormatter::try_new("%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)%").unwrap();
         let expected = "/original";
 
         formatter.with_context(&DownstreamRequest(&req));
@@ -203,7 +204,7 @@ mod tests {
     #[test]
     fn test_request_method() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
+        let formatter = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
         println!("FORMATTER: {:?}", formatter);
         let expected = "GET";
         formatter.with_context(&DownstreamRequest(&req));
@@ -214,7 +215,7 @@ mod tests {
     #[test]
     fn test_request_protocol() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new("%PROTOCOL%").unwrap();
+        let formatter = LogFormatter::try_new("%PROTOCOL%").unwrap();
         println!("FORMATTER: {:?}", formatter);
         let expected = "HTTP/1.1";
         formatter.with_context(&DownstreamRequest(&req));
@@ -225,7 +226,7 @@ mod tests {
     #[test]
     fn test_request_upstream_protocol() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new("%UPSTREAM_PROTOCOL%").unwrap();
+        let formatter = LogFormatter::try_new("%UPSTREAM_PROTOCOL%").unwrap();
         println!("FORMATTER: {:?}", formatter);
         let expected = "HTTP/1.1";
         formatter.with_context(&UpstreamRequest(&req));
@@ -236,7 +237,7 @@ mod tests {
     #[test]
     fn test_request_scheme() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new("%REQ(:SCHEME)%").unwrap();
+        let formatter = LogFormatter::try_new("%REQ(:SCHEME)%").unwrap();
         let expected = "https";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -246,7 +247,7 @@ mod tests {
     #[test]
     fn test_request_authority() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new("%REQ(:AUTHORITY)%").unwrap();
+        let formatter = LogFormatter::try_new("%REQ(:AUTHORITY)%").unwrap();
         let expected = "www.rust-lang.org";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -256,7 +257,7 @@ mod tests {
     #[test]
     fn test_request_user_agent() {
         let req = build_request();
-        let mut formatter = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
+        let formatter = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
         let expected = "awesome/1.0";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -274,7 +275,7 @@ mod tests {
     fn default_format_string() {
         let req = build_request();
         let resp = build_response();
-        let mut formatter = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap();
+        let formatter = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap();
         formatter.with_context(&InitContext { start_time: std::time::SystemTime::now() });
         formatter.with_context(&UpstreamContext { authority: &req.uri().authority().unwrap() });
         formatter.with_context(&DownstreamRequest(&req));

From 1c1387e0bab1d16d1b4ff5c84d2757fc980cd6d1 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Thu, 22 May 2025 10:16:52 +0200
Subject: [PATCH 42/64] Refactor LogFormatter to use LogFormatterCell

- Introduced LogFormatterCell with RefCell for mutable state.
- Updated benchmarks and tests to use LogFormatterCell.
- Added conversion methods between LogFormatter and LogFormatterCell.
- Simplified write_to and Display implementations.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs   |  37 +++++-----
 orion-format/src/bin/format-test.rs |   8 +--
 orion-format/src/lib.rs             | 106 +++++++++++++++++++++-------
 3 files changed, 99 insertions(+), 52 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index f8960906..351fcbde 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -4,7 +4,7 @@ use http::{HeaderMap, HeaderName, HeaderValue, Request, Response, StatusCode, Ve
 use orion_format::{
     context::{Context, DownstreamRequest, DownstreamResponse, FinishContext, InitContext},
     types::{ResponseFlags, ResponseFlagsShort},
-    LogFormatter, DEFAULT_ENVOY_FORMAT,
+    LogFormatter, LogFormatterCell, DEFAULT_ENVOY_FORMAT,
 };
 use smol_str::ToSmolStr;
 use std::time::Duration;
@@ -14,7 +14,7 @@ use std::time::Duration;
 static ALLOC: dhat::Alloc = dhat::Alloc;
 
 #[inline]
-fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter)
+fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &LogFormatterCell)
 where
     C1: Context,
     C2: Context,
@@ -131,20 +131,14 @@ fn benchmark_log_formatter(c: &mut Criterion) {
 
     c.bench_function("log_formatter_full", |b| {
         b.iter(|| {
-            let mut fmt = fmt.clone();
-            black_box(eval_format(
-                &DownstreamRequest(&request),
-                &DownstreamResponse(&response),
-                &start,
-                &end,
-                &mut fmt,
-            ));
+            let fmt = fmt.to_cell();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt));
         })
     });
 
     c.bench_function("log_formatter_full_write", |b| {
         b.iter(|| {
-            let mut fmt = fmt.clone();
+            let mut fmt = fmt.to_cell();
             black_box(eval_format(
                 &DownstreamRequest(&request),
                 &DownstreamResponse(&response),
@@ -152,7 +146,7 @@ fn benchmark_log_formatter(c: &mut Criterion) {
                 &end,
                 &mut fmt,
             ));
-            _ = black_box(|| fmt.write_to(&mut sink));
+            _ = black_box(|| fmt.into_inner().write_to(&mut sink));
         })
     });
 
@@ -162,12 +156,13 @@ fn benchmark_log_formatter(c: &mut Criterion) {
         })
     });
 
-    let mut formatted = fmt.clone();
-    eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut formatted);
+    let formatted = fmt.to_cell();
+    eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &formatted);
 
+    let fmt = formatted.into_inner();
     c.bench_function("log_formatter_write_only", |b| {
         b.iter(|| {
-            _ = black_box(|| formatted.write_to(&mut sink));
+            _ = black_box(|| fmt.write_to(&mut sink));
         })
     });
 }
@@ -191,24 +186,24 @@ fn benchmark_request_parts(c: &mut Criterion) {
     let fmt = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
     c.bench_function("REQ(:PATH)", |b| {
         b.iter(|| {
-            let mut fmt = fmt.clone();
-            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt))
+            let fmt = fmt.to_cell();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt))
         })
     });
 
     let fmt = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
     c.bench_function("REQ(:METHOD)", |b| {
         b.iter(|| {
-            let mut fmt = fmt.clone();
-            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt))
+            let fmt = fmt.to_cell();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt))
         })
     });
 
     let fmt = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
     c.bench_function("REQ(USER-AGENT)", |b| {
         b.iter(|| {
-            let mut fmt = fmt.clone();
-            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt))
+            let fmt = fmt.to_cell();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt))
         })
     });
 }
diff --git a/orion-format/src/bin/format-test.rs b/orion-format/src/bin/format-test.rs
index bf83baf7..9182d446 100644
--- a/orion-format/src/bin/format-test.rs
+++ b/orion-format/src/bin/format-test.rs
@@ -3,14 +3,14 @@ use http::{Request, Response, StatusCode};
 use orion_format::{
     context::{Context, DownstreamRequest, DownstreamResponse, FinishContext, InitContext},
     types::ResponseFlags,
-    LogFormatter,
+    LogFormatter, LogFormatterCell,
 };
 use std::time::{Duration, Instant};
 
 const DEF_FMT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
 
 #[inline]
-fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter)
+fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &LogFormatterCell)
 where
     C1: Context,
     C2: Context,
@@ -49,8 +49,8 @@ fn main() {
     let now = Instant::now();
 
     for _ in 0..TOTAL {
-        let mut fmt_ = black_box(fmt.clone());
-        black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt_));
+        let fmt = black_box(fmt.to_cell());
+        black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt));
         // _ = black_box(|| fmt_.write_to(&mut sink));
     }
 
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index f2861076..77efc151 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -17,7 +17,7 @@ use thiserror::Error;
 
 use crate::grammar::EnvoyGrammar;
 
-pub const DEFAULT_ENVOY_FORMAT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%"\n"#;
+pub const DEFAULT_ENVOY_FORMAT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
 
 #[derive(Error, Debug)]
 pub enum FormatError {
@@ -60,6 +60,12 @@ struct IndexedTemplate {
 
 #[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub struct LogFormatter {
+    catalog: Arc<IndexedTemplate>,
+    format: Vec<StringType>,
+}
+
+#[derive(PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub struct LogFormatterCell {
     catalog: Arc<IndexedTemplate>,
     format: RefCell<Vec<StringType>>,
 }
@@ -91,24 +97,12 @@ impl LogFormatter {
             }
         }
 
-        Ok(LogFormatter { catalog: Arc::new(IndexedTemplate { templates, indices }), format: RefCell::new(format) })
-    }
-
-    pub fn with_context<'a, C: Context>(&self, ctx: &'a C) -> &Self {
-        for idx in &self.catalog.indices[C::category() as usize] {
-            unsafe {
-                if let Template::Placeholder(op, _) = self.catalog.templates.get_unchecked(*idx as usize) {
-                    *self.format.borrow_mut().get_unchecked_mut(*idx as usize) = ctx.eval_part(&op);
-                }
-            }
-        }
-
-        self
+        Ok(LogFormatter { catalog: Arc::new(IndexedTemplate { templates, indices }), format })
     }
 
     pub fn write_to<W: std::io::Write>(&self, w: &mut W) -> std::io::Result<usize> {
         let mut total_bytes = 0;
-        for (_part, out) in self.catalog.templates.iter().zip(self.format.borrow().iter()) {
+        for (_part, out) in self.catalog.templates.iter().zip(self.format.iter()) {
             total_bytes += match out {
                 StringType::Smol(s) => IoWrite::write(w, s.as_bytes())?,
                 StringType::Char(c) => {
@@ -127,6 +121,34 @@ impl LogFormatter {
         Ok(total_bytes)
     }
 
+    pub fn to_cell(&self) -> LogFormatterCell {
+        LogFormatterCell { catalog: Arc::clone(&self.catalog), format: RefCell::new(self.format.clone()) }
+    }
+
+    #[inline]
+    pub fn is_fully_formatted(&self) -> bool {
+        self.format.iter().all(|f| *f != StringType::None)
+    }
+}
+
+impl LogFormatterCell {
+    pub fn with_context<'a, C: Context>(&self, ctx: &'a C) -> &Self {
+        for idx in &self.catalog.indices[C::category() as usize] {
+            unsafe {
+                if let Template::Placeholder(op, _) = self.catalog.templates.get_unchecked(*idx as usize) {
+                    *self.format.borrow_mut().get_unchecked_mut(*idx as usize) = ctx.eval_part(&op);
+                }
+            }
+        }
+
+        self
+    }
+
+    #[inline]
+    pub fn into_inner(self) -> LogFormatter {
+        LogFormatter { catalog: self.catalog, format: self.format.into_inner() }
+    }
+
     #[inline]
     pub fn is_fully_formatted(&self) -> bool {
         self.format.borrow().iter().all(|f| *f != StringType::None)
@@ -134,13 +156,33 @@ impl LogFormatter {
 }
 
 impl Display for LogFormatter {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        for (_part, out) in self.catalog.templates.iter().zip(self.format.iter()) {
+            match out {
+                StringType::Smol(s) => f.write_str(s.as_ref())?,
+                StringType::Char(c) => f.write_char(*c)?,
+                // StringType::Compact(s) => f.write_str(s.as_ref())?,
+                #[cfg(debug_assertions)]
+                _ => f.write_str(&format!("%{:?}%", _part))?,
+                #[cfg(not(debug_assertions))]
+                _ => f.write_str(&format!("?"))?,
+            };
+        }
+        Ok(())
+    }
+}
+
+impl Display for LogFormatterCell {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         for (part, out) in self.catalog.templates.iter().zip(self.format.borrow().iter()) {
             match out {
                 StringType::Smol(s) => f.write_str(s.as_ref())?,
                 StringType::Char(c) => f.write_char(*c)?,
                 // StringType::Compact(s) => f.write_str(s.as_ref())?,
+                #[cfg(debug_assertions)]
                 _ => f.write_str(&format!("%{:?}%", part))?,
+                #[cfg(not(debug_assertions))]
+                _ => f.write_str(&format!("?"))?,
             };
         }
         Ok(())
@@ -180,7 +222,8 @@ mod tests {
         let mut req = build_request();
         req.headers_mut().append("X-ENVOY-ORIGINAL-PATH", HeaderValue::from_static("/original"));
 
-        let formatter = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
+        let source = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
+        let formatter = source.to_cell();
         let expected = "/";
 
         formatter.with_context(&DownstreamRequest(&req));
@@ -193,7 +236,8 @@ mod tests {
         let mut req = build_request();
         req.headers_mut().append("X-ENVOY-ORIGINAL-PATH", HeaderValue::from_static("/original"));
 
-        let formatter = LogFormatter::try_new("%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)%").unwrap();
+        let source = LogFormatter::try_new("%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)%").unwrap();
+        let formatter = source.to_cell();
         let expected = "/original";
 
         formatter.with_context(&DownstreamRequest(&req));
@@ -204,7 +248,8 @@ mod tests {
     #[test]
     fn test_request_method() {
         let req = build_request();
-        let formatter = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
+        let source = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
+        let formatter = source.to_cell();
         println!("FORMATTER: {:?}", formatter);
         let expected = "GET";
         formatter.with_context(&DownstreamRequest(&req));
@@ -215,7 +260,8 @@ mod tests {
     #[test]
     fn test_request_protocol() {
         let req = build_request();
-        let formatter = LogFormatter::try_new("%PROTOCOL%").unwrap();
+        let source = LogFormatter::try_new("%PROTOCOL%").unwrap();
+        let formatter = source.to_cell();
         println!("FORMATTER: {:?}", formatter);
         let expected = "HTTP/1.1";
         formatter.with_context(&DownstreamRequest(&req));
@@ -226,7 +272,8 @@ mod tests {
     #[test]
     fn test_request_upstream_protocol() {
         let req = build_request();
-        let formatter = LogFormatter::try_new("%UPSTREAM_PROTOCOL%").unwrap();
+        let source = LogFormatter::try_new("%UPSTREAM_PROTOCOL%").unwrap();
+        let formatter = source.to_cell();
         println!("FORMATTER: {:?}", formatter);
         let expected = "HTTP/1.1";
         formatter.with_context(&UpstreamRequest(&req));
@@ -237,7 +284,8 @@ mod tests {
     #[test]
     fn test_request_scheme() {
         let req = build_request();
-        let formatter = LogFormatter::try_new("%REQ(:SCHEME)%").unwrap();
+        let source = LogFormatter::try_new("%REQ(:SCHEME)%").unwrap();
+        let formatter = source.to_cell();
         let expected = "https";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -247,7 +295,8 @@ mod tests {
     #[test]
     fn test_request_authority() {
         let req = build_request();
-        let formatter = LogFormatter::try_new("%REQ(:AUTHORITY)%").unwrap();
+        let source = LogFormatter::try_new("%REQ(:AUTHORITY)%").unwrap();
+        let formatter = source.to_cell();
         let expected = "www.rust-lang.org";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -257,7 +306,8 @@ mod tests {
     #[test]
     fn test_request_user_agent() {
         let req = build_request();
-        let formatter = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
+        let source = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
+        let formatter = source.to_cell();
         let expected = "awesome/1.0";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -266,7 +316,8 @@ mod tests {
 
     #[test]
     fn test_unevaluated_operator() {
-        let formatter = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
+        let source = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
+        let formatter = source.to_cell();
         let actual = format!("{}", &formatter);
         println!("{actual}");
     }
@@ -275,10 +326,11 @@ mod tests {
     fn default_format_string() {
         let req = build_request();
         let resp = build_response();
-        let formatter = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap();
+        let source = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap();
+        let formatter = source.to_cell();
         formatter.with_context(&InitContext { start_time: std::time::SystemTime::now() });
-        formatter.with_context(&UpstreamContext { authority: &req.uri().authority().unwrap() });
         formatter.with_context(&DownstreamRequest(&req));
+        formatter.with_context(&UpstreamContext { authority: &req.uri().authority().unwrap() });
         formatter.with_context(&DownstreamResponse(&resp));
         formatter.with_context(&FinishContext {
             duration: Duration::from_millis(100),
@@ -287,6 +339,6 @@ mod tests {
             response_flags: ResponseFlags::NO_HEALTHY_UPSTREAM,
         });
         assert!(formatter.is_fully_formatted());
-        println!("{}", &formatter);
+        println!("{}", &source);
     }
 }

From ee729e4921224ed18031955a9204174f2a974c94 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Thu, 22 May 2025 14:26:46 +0200
Subject: [PATCH 43/64] Remove LogFormatterCell, unsuitable for easy use in the
 Tokyo context.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs   | 37 +++++++++-------
 orion-format/src/bin/format-test.rs |  8 ++--
 orion-format/src/lib.rs             | 66 ++++++-----------------------
 orion-xds/src/xds/request.rs        |  2 +-
 4 files changed, 39 insertions(+), 74 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 351fcbde..f8960906 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -4,7 +4,7 @@ use http::{HeaderMap, HeaderName, HeaderValue, Request, Response, StatusCode, Ve
 use orion_format::{
     context::{Context, DownstreamRequest, DownstreamResponse, FinishContext, InitContext},
     types::{ResponseFlags, ResponseFlagsShort},
-    LogFormatter, LogFormatterCell, DEFAULT_ENVOY_FORMAT,
+    LogFormatter, DEFAULT_ENVOY_FORMAT,
 };
 use smol_str::ToSmolStr;
 use std::time::Duration;
@@ -14,7 +14,7 @@ use std::time::Duration;
 static ALLOC: dhat::Alloc = dhat::Alloc;
 
 #[inline]
-fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &LogFormatterCell)
+fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter)
 where
     C1: Context,
     C2: Context,
@@ -131,14 +131,20 @@ fn benchmark_log_formatter(c: &mut Criterion) {
 
     c.bench_function("log_formatter_full", |b| {
         b.iter(|| {
-            let fmt = fmt.to_cell();
-            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt));
+            let mut fmt = fmt.clone();
+            black_box(eval_format(
+                &DownstreamRequest(&request),
+                &DownstreamResponse(&response),
+                &start,
+                &end,
+                &mut fmt,
+            ));
         })
     });
 
     c.bench_function("log_formatter_full_write", |b| {
         b.iter(|| {
-            let mut fmt = fmt.to_cell();
+            let mut fmt = fmt.clone();
             black_box(eval_format(
                 &DownstreamRequest(&request),
                 &DownstreamResponse(&response),
@@ -146,7 +152,7 @@ fn benchmark_log_formatter(c: &mut Criterion) {
                 &end,
                 &mut fmt,
             ));
-            _ = black_box(|| fmt.into_inner().write_to(&mut sink));
+            _ = black_box(|| fmt.write_to(&mut sink));
         })
     });
 
@@ -156,13 +162,12 @@ fn benchmark_log_formatter(c: &mut Criterion) {
         })
     });
 
-    let formatted = fmt.to_cell();
-    eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &formatted);
+    let mut formatted = fmt.clone();
+    eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut formatted);
 
-    let fmt = formatted.into_inner();
     c.bench_function("log_formatter_write_only", |b| {
         b.iter(|| {
-            _ = black_box(|| fmt.write_to(&mut sink));
+            _ = black_box(|| formatted.write_to(&mut sink));
         })
     });
 }
@@ -186,24 +191,24 @@ fn benchmark_request_parts(c: &mut Criterion) {
     let fmt = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
     c.bench_function("REQ(:PATH)", |b| {
         b.iter(|| {
-            let fmt = fmt.to_cell();
-            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt))
+            let mut fmt = fmt.clone();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt))
         })
     });
 
     let fmt = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
     c.bench_function("REQ(:METHOD)", |b| {
         b.iter(|| {
-            let fmt = fmt.to_cell();
-            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt))
+            let mut fmt = fmt.clone();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt))
         })
     });
 
     let fmt = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
     c.bench_function("REQ(USER-AGENT)", |b| {
         b.iter(|| {
-            let fmt = fmt.to_cell();
-            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt))
+            let mut fmt = fmt.clone();
+            black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt))
         })
     });
 }
diff --git a/orion-format/src/bin/format-test.rs b/orion-format/src/bin/format-test.rs
index 9182d446..60db8dd7 100644
--- a/orion-format/src/bin/format-test.rs
+++ b/orion-format/src/bin/format-test.rs
@@ -3,14 +3,14 @@ use http::{Request, Response, StatusCode};
 use orion_format::{
     context::{Context, DownstreamRequest, DownstreamResponse, FinishContext, InitContext},
     types::ResponseFlags,
-    LogFormatter, LogFormatterCell,
+    LogFormatter,
 };
 use std::time::{Duration, Instant};
 
 const DEF_FMT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
 
 #[inline]
-fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &LogFormatterCell)
+fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter)
 where
     C1: Context,
     C2: Context,
@@ -49,8 +49,8 @@ fn main() {
     let now = Instant::now();
 
     for _ in 0..TOTAL {
-        let fmt = black_box(fmt.to_cell());
-        black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &fmt));
+        let mut fmt = black_box(fmt.clone());
+        black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt));
         // _ = black_box(|| fmt_.write_to(&mut sink));
     }
 
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 77efc151..8f25c103 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -8,7 +8,6 @@ use context::Context;
 use operator::{Category, Operator};
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
-use std::cell::RefCell;
 use std::fmt::{self, Display, Formatter, Write};
 use std::io::Write as IoWrite;
 use std::sync::Arc;
@@ -64,12 +63,6 @@ pub struct LogFormatter {
     format: Vec<StringType>,
 }
 
-#[derive(PartialEq, Eq, Debug, Serialize, Deserialize)]
-pub struct LogFormatterCell {
-    catalog: Arc<IndexedTemplate>,
-    format: RefCell<Vec<StringType>>,
-}
-
 impl Default for LogFormatter {
     fn default() -> Self {
         LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap()
@@ -121,22 +114,11 @@ impl LogFormatter {
         Ok(total_bytes)
     }
 
-    pub fn to_cell(&self) -> LogFormatterCell {
-        LogFormatterCell { catalog: Arc::clone(&self.catalog), format: RefCell::new(self.format.clone()) }
-    }
-
-    #[inline]
-    pub fn is_fully_formatted(&self) -> bool {
-        self.format.iter().all(|f| *f != StringType::None)
-    }
-}
-
-impl LogFormatterCell {
-    pub fn with_context<'a, C: Context>(&self, ctx: &'a C) -> &Self {
+    pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &Self {
         for idx in &self.catalog.indices[C::category() as usize] {
             unsafe {
                 if let Template::Placeholder(op, _) = self.catalog.templates.get_unchecked(*idx as usize) {
-                    *self.format.borrow_mut().get_unchecked_mut(*idx as usize) = ctx.eval_part(&op);
+                    *self.format.get_unchecked_mut(*idx as usize) = ctx.eval_part(&op);
                 }
             }
         }
@@ -144,14 +126,9 @@ impl LogFormatterCell {
         self
     }
 
-    #[inline]
-    pub fn into_inner(self) -> LogFormatter {
-        LogFormatter { catalog: self.catalog, format: self.format.into_inner() }
-    }
-
     #[inline]
     pub fn is_fully_formatted(&self) -> bool {
-        self.format.borrow().iter().all(|f| *f != StringType::None)
+        self.format.iter().all(|f| *f != StringType::None)
     }
 }
 
@@ -172,23 +149,6 @@ impl Display for LogFormatter {
     }
 }
 
-impl Display for LogFormatterCell {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        for (part, out) in self.catalog.templates.iter().zip(self.format.borrow().iter()) {
-            match out {
-                StringType::Smol(s) => f.write_str(s.as_ref())?,
-                StringType::Char(c) => f.write_char(*c)?,
-                // StringType::Compact(s) => f.write_str(s.as_ref())?,
-                #[cfg(debug_assertions)]
-                _ => f.write_str(&format!("%{:?}%", part))?,
-                #[cfg(not(debug_assertions))]
-                _ => f.write_str(&format!("?"))?,
-            };
-        }
-        Ok(())
-    }
-}
-
 pub trait Grammar {
     fn parse(input: &str) -> Result<Vec<Template>, FormatError>;
 }
@@ -223,7 +183,7 @@ mod tests {
         req.headers_mut().append("X-ENVOY-ORIGINAL-PATH", HeaderValue::from_static("/original"));
 
         let source = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
-        let formatter = source.to_cell();
+        let mut formatter = source.clone();
         let expected = "/";
 
         formatter.with_context(&DownstreamRequest(&req));
@@ -237,7 +197,7 @@ mod tests {
         req.headers_mut().append("X-ENVOY-ORIGINAL-PATH", HeaderValue::from_static("/original"));
 
         let source = LogFormatter::try_new("%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)%").unwrap();
-        let formatter = source.to_cell();
+        let mut formatter = source.clone();
         let expected = "/original";
 
         formatter.with_context(&DownstreamRequest(&req));
@@ -249,7 +209,7 @@ mod tests {
     fn test_request_method() {
         let req = build_request();
         let source = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
-        let formatter = source.to_cell();
+        let mut formatter = source.clone();
         println!("FORMATTER: {:?}", formatter);
         let expected = "GET";
         formatter.with_context(&DownstreamRequest(&req));
@@ -261,7 +221,7 @@ mod tests {
     fn test_request_protocol() {
         let req = build_request();
         let source = LogFormatter::try_new("%PROTOCOL%").unwrap();
-        let formatter = source.to_cell();
+        let mut formatter = source.clone();
         println!("FORMATTER: {:?}", formatter);
         let expected = "HTTP/1.1";
         formatter.with_context(&DownstreamRequest(&req));
@@ -273,7 +233,7 @@ mod tests {
     fn test_request_upstream_protocol() {
         let req = build_request();
         let source = LogFormatter::try_new("%UPSTREAM_PROTOCOL%").unwrap();
-        let formatter = source.to_cell();
+        let mut formatter = source.clone();
         println!("FORMATTER: {:?}", formatter);
         let expected = "HTTP/1.1";
         formatter.with_context(&UpstreamRequest(&req));
@@ -285,7 +245,7 @@ mod tests {
     fn test_request_scheme() {
         let req = build_request();
         let source = LogFormatter::try_new("%REQ(:SCHEME)%").unwrap();
-        let formatter = source.to_cell();
+        let mut formatter = source.clone();
         let expected = "https";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -296,7 +256,7 @@ mod tests {
     fn test_request_authority() {
         let req = build_request();
         let source = LogFormatter::try_new("%REQ(:AUTHORITY)%").unwrap();
-        let formatter = source.to_cell();
+        let mut formatter = source.clone();
         let expected = "www.rust-lang.org";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -307,7 +267,7 @@ mod tests {
     fn test_request_user_agent() {
         let req = build_request();
         let source = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
-        let formatter = source.to_cell();
+        let mut formatter = source.clone();
         let expected = "awesome/1.0";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter);
@@ -317,7 +277,7 @@ mod tests {
     #[test]
     fn test_unevaluated_operator() {
         let source = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
-        let formatter = source.to_cell();
+        let formatter = source.clone();
         let actual = format!("{}", &formatter);
         println!("{actual}");
     }
@@ -327,7 +287,7 @@ mod tests {
         let req = build_request();
         let resp = build_response();
         let source = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap();
-        let formatter = source.to_cell();
+        let mut formatter = source.clone();
         formatter.with_context(&InitContext { start_time: std::time::SystemTime::now() });
         formatter.with_context(&DownstreamRequest(&req));
         formatter.with_context(&UpstreamContext { authority: &req.uri().authority().unwrap() });
diff --git a/orion-xds/src/xds/request.rs b/orion-xds/src/xds/request.rs
index c6fb3953..8873ff05 100644
--- a/orion-xds/src/xds/request.rs
+++ b/orion-xds/src/xds/request.rs
@@ -1,5 +1,5 @@
 use super::model::{ResourceId, ResourceVersion, TypeUrl};
-use ng2_data_plane_api::envoy_data_plane_api::{
+use orion_data_plane_api::envoy_data_plane_api::{
     envoy::{config::core::v3::Node as EnvoyNode, service::discovery::v3::DeltaDiscoveryRequest},
     google::rpc::Status,
     tonic,

From 087d2fef7b1a32d8cab6956aa93e2e9dbb7c55a1 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Thu, 22 May 2025 16:18:47 +0200
Subject: [PATCH 44/64] Update Cargo.lock and refactor authority handling

- Added new dependencies to Cargo.lock, including `criterion`,
  `chrono`, `smol_str`, and others.
- Updated versions for existing dependencies like `bitflags`
  and `itoa`.
- Refactored `Context` implementations to use `as_str` for
  authority extraction.
- Introduced `extract_authority_from_request` to handle
  authority extraction with fallback to `Host` header.
```

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 Cargo.lock                  | 466 ++++++++++++++++++++++++++++++------
 orion-format/src/context.rs |  17 +-
 2 files changed, 407 insertions(+), 76 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f667a54c..f5bdcc0b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -47,6 +47,27 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
 [[package]]
 name = "anstream"
 version = "0.6.20"
@@ -99,9 +120,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.98"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100"
 
 [[package]]
 name = "asn1-rs"
@@ -166,9 +187,9 @@ dependencies = [
 
 [[package]]
 name = "async-trait"
-version = "0.1.88"
+version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -335,9 +356,18 @@ dependencies = [
 
 [[package]]
 name = "bitflags"
-version = "2.9.1"
+version = "2.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+checksum = "6a65b545ab31d687cff52899d4890855fec459eb6afe0da6417b8a18da87aa29"
+
+[[package]]
+name = "borsh"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8646f98db542e39fc66e68a20b2144f6a732636df7c2354e74645faaa433ce"
+dependencies = [
+ "cfg_aliases",
+]
 
 [[package]]
 name = "bumpalo"
@@ -367,6 +397,12 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
 [[package]]
 name = "castaway"
 version = "0.2.4"
@@ -378,9 +414,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.31"
+version = "1.2.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3a42d84bb6b69d3a8b3eaacf0d88f179e1929695e1ad012b6cf64d9caaa5fd2"
+checksum = "3ee0f8803222ba5a7e2777dd72ca451868909b1ac410621b676adf07280e9b5f"
 dependencies = [
  "jobserver",
  "libc",
@@ -404,9 +440,56 @@ dependencies = [
 
 [[package]]
 name = "cfg-if"
-version = "1.0.1"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "chrono"
+version = "0.4.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
 
 [[package]]
 name = "clang-sys"
@@ -421,9 +504,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.43"
+version = "4.5.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50fd97c9dc2399518aa331917ac6f274280ec5eb34e555dd291899745c48ec6f"
+checksum = "1fc0e74a703892159f5ae7d3aac52c8e6c392f5ae5f359c70b5881d60aaac318"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -431,9 +514,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.43"
+version = "4.5.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c35b5830294e1fa0462034af85cc95225a4cb07092c088c55bda3147cfcd8f65"
+checksum = "b3e7f4214277f3c7aa526a59dd3fbe306a370daee1f8b7b8c987069cd8e888a8"
 dependencies = [
  "anstream",
  "anstyle",
@@ -443,9 +526,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.41"
+version = "4.5.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef4f52386a59ca4c860f7393bcf8abd8dfd91ecccc0f774635ff68e92eeef491"
+checksum = "14cb31bb0a7d536caef2639baa7fad459e15c3144efefa6dbd1c84562c4739f6"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -573,6 +656,42 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools 0.10.5",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools 0.10.5",
+]
+
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.15"
@@ -582,12 +701,37 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
 [[package]]
 name = "data-encoding"
 version = "2.9.0"
@@ -751,9 +895,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.2.1"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
 dependencies = [
  "percent-encoding",
 ]
@@ -884,9 +1028,9 @@ checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
 
 [[package]]
 name = "glob"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "h2"
@@ -907,6 +1051,16 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "half"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -1072,13 +1226,14 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc2b571658e38e0c01b1fdca3bbbe93c00d3d71693ff2770043f8c29bc7d6f80"
+checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e"
 dependencies = [
+ "atomic-waker",
  "bytes",
  "futures-channel",
- "futures-util",
+ "futures-core",
  "h2",
  "http",
  "http-body",
@@ -1086,6 +1241,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
+ "pin-utils",
  "smallvec",
  "tokio",
  "want",
@@ -1148,6 +1304,30 @@ dependencies = [
  "windows-registry",
 ]
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "icu_collections"
 version = "2.0.0"
@@ -1236,9 +1416,9 @@ dependencies = [
 
 [[package]]
 name = "idna"
-version = "1.0.3"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
 dependencies = [
  "idna_adapter",
  "smallvec",
@@ -1307,12 +1487,32 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "is-terminal"
+version = "0.4.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itertools"
 version = "0.12.1"
@@ -1391,9 +1591,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.174"
+version = "0.2.175"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
 
 [[package]]
 name = "libloading"
@@ -1613,6 +1813,12 @@ version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
 
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
 [[package]]
 name = "openssl-probe"
 version = "0.1.6"
@@ -1651,7 +1857,7 @@ dependencies = [
  "serde_path_to_error",
  "serde_regex",
  "serde_yaml",
- "thiserror 2.0.12",
+ "thiserror 2.0.16",
  "tracing",
  "tracing-subscriber",
  "tracing-test",
@@ -1669,7 +1875,7 @@ dependencies = [
  "hyper-util",
  "serde",
  "serde_yaml",
- "thiserror 2.0.12",
+ "thiserror 2.0.16",
  "tokio",
  "tokio-stream",
  "tokio-util",
@@ -1685,12 +1891,21 @@ version = "0.1.0"
 name = "orion-format"
 version = "0.1.0"
 dependencies = [
+ "bitflags",
+ "chrono",
+ "compact_str",
+ "criterion",
+ "dhat",
  "http",
+ "http-serde-ext",
+ "itoa",
  "lazy_static",
  "ptrie",
+ "serde",
+ "smol_str",
  "strum",
  "strum_macros",
- "thiserror",
+ "thiserror 2.0.16",
 ]
 
 [[package]]
@@ -1733,7 +1948,7 @@ dependencies = [
  "rustls-webpki 0.102.8",
  "serde",
  "serde_yaml",
- "thiserror 2.0.12",
+ "thiserror 2.0.16",
  "thread_local",
  "tokio",
  "tokio-rustls",
@@ -1787,12 +2002,11 @@ dependencies = [
  "orion-error",
  "serde",
  "serde_yaml",
- "thiserror 2.0.12",
+ "thiserror 2.0.16",
  "tokio",
  "tokio-stream",
  "tower 0.5.2",
  "tracing",
- "tracing-subscriber",
  "uuid",
 ]
 
@@ -1827,9 +2041,9 @@ dependencies = [
 
 [[package]]
 name = "percent-encoding"
-version = "2.3.1"
+version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
 name = "petgraph"
@@ -1887,6 +2101,34 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
+
 [[package]]
 name = "portable-atomic"
 version = "1.11.1"
@@ -1925,9 +2167,9 @@ checksum = "d8868e7264af614b3634ff0abbe37b178e61000611b8a75221aea40221924aba"
 
 [[package]]
 name = "prettyplease"
-version = "0.2.36"
+version = "0.2.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
  "syn",
@@ -1935,9 +2177,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
 dependencies = [
  "unicode-ident",
 ]
@@ -2026,12 +2268,6 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4debfffbf1669869b4bea1bab297f8e9ec11900a9ff2dcf659c2a1c4918c811a"
 
-[[package]]
-name = "quick-error"
-version = "1.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
-
 [[package]]
 name = "quote"
 version = "1.0.40"
@@ -2077,6 +2313,26 @@ dependencies = [
  "getrandom 0.2.16",
 ]
 
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.17"
@@ -2313,9 +2569,9 @@ dependencies = [
 
 [[package]]
 name = "rustversion"
-version = "1.0.21"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "ryu"
@@ -2416,9 +2672,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.142"
+version = "1.0.143"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7"
+checksum = "d401abef1d108fbd9cbaebc3e46611f4b1021f714a0597a71f41ee463f5f4a5a"
 dependencies = [
  "itoa",
  "memchr",
@@ -2495,6 +2751,16 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
+[[package]]
+name = "smol_str"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9676b89cd56310a87b93dec47b11af744f34d5fc9f367b829474eec0a891350d"
+dependencies = [
+ "borsh",
+ "serde",
+]
+
 [[package]]
 name = "socket2"
 version = "0.5.10"
@@ -2535,23 +2801,22 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "strum"
-version = "0.27.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
 dependencies = [
  "strum_macros",
 ]
 
 [[package]]
 name = "strum_macros"
-version = "0.27.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "rustversion",
  "syn",
 ]
 
@@ -2563,9 +2828,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "2.0.104"
+version = "2.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2612,15 +2877,15 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.20.0"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
+checksum = "15b61f8f20e3a6f7e0649d825294eaf317edce30f82cf6026e7e4cb9222a7d1e"
 dependencies = [
  "fastrand",
  "getrandom 0.3.3",
  "once_cell",
  "rustix 1.0.8",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -2634,11 +2899,11 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.12"
+version = "2.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+checksum = "3467d614147380f2e4e374161426ff399c91084acd2363eaf549172b3d5e60c0"
 dependencies = [
- "thiserror-impl 2.0.12",
+ "thiserror-impl 2.0.16",
 ]
 
 [[package]]
@@ -2654,9 +2919,9 @@ dependencies = [
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.12"
+version = "2.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+checksum = "6c5e1be1c48b9172ee610da68fd9cd2770e7a4056cb3fc98710ee6906f0c7960"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2739,11 +3004,21 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "tinyvec"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -3076,9 +3351,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "url"
-version = "2.5.4"
+version = "2.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
+checksum = "ec961601b32b6f5d14ae8dabd35ff2ff2e2c6cb4c0e6641845ff105abe96d958"
 dependencies = [
  "form_urlencoded",
  "idna",
@@ -3099,9 +3374,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.17.0"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cf4199d1e5d15ddd86a694e4d0dffa9c323ce759fea589f00fef9d81cc1931d"
+checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be"
 dependencies = [
  "getrandom 0.3.3",
  "js-sys",
@@ -3206,6 +3481,16 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "web-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "0.26.11"
@@ -3260,11 +3545,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.9"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+checksum = "0978bf7171b3d90bac376700cb56d606feb40f251a475a5d6634613564460b22"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -3273,6 +3558,41 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "windows-link"
 version = "0.1.3"
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 7f201394..116ec85c 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -45,7 +45,7 @@ impl<'c> Context for UpstreamContext<'c> {
     }
     fn eval_part<'a>(&'a self, op: &Operator) -> StringType {
         match op {
-            Operator::UpstreamHost => StringType::Smol(SmolStr::new(self.authority.host())),
+            Operator::UpstreamHost => StringType::Smol(SmolStr::new(self.authority.as_str())),
             _ => StringType::None,
         }
     }
@@ -111,8 +111,8 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
                 StringType::Smol(SmolStr::new(path_str))
             },
             Operator::RequestAuthority => {
-                if let Some(a) = self.0.uri().authority() {
-                    StringType::Smol(SmolStr::new(a.host()))
+                if let Some(a) = extract_authority_from_request(self.0) {
+                    StringType::Smol(SmolStr::new(a))
                 } else {
                     StringType::None
                 }
@@ -183,6 +183,17 @@ impl<'a, T> Context for DownstreamResponse<'a, T> {
     }
 }
 
+pub fn extract_authority_from_request<T>(request: &Request<T>) -> Option<&str> {
+    if let Some(authority) = request.uri().authority() {
+        return Some(authority.as_str());
+    }
+    if let Some(host_header_value) = request.headers().get(http::header::HOST) {
+        return host_header_value.to_str().ok();
+    }
+
+    None
+}
+
 const TWO_DIGITS: [&str; 100] = [
     "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17", "18",
     "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37",

From 127903cf3c8423a6f249368de68cc902631c41f4 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 23 May 2025 08:37:52 +0200
Subject: [PATCH 45/64] Refactor LogFormatter to use FormattedMessage for
 output

- Introduced FormattedMessage struct to encapsulate formatted output only.
- Moved write_to and is_fully_formatted methods to FormattedMessage.
- Updated LogFormatter to convert into FormattedMessage via into_message.
- Adjusted benchmarks and tests to use FormattedMessage.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs |  5 +-
 orion-format/src/lib.rs           | 83 +++++++++++++++++--------------
 2 files changed, 50 insertions(+), 38 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index f8960906..88811f79 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -152,7 +152,7 @@ fn benchmark_log_formatter(c: &mut Criterion) {
                 &end,
                 &mut fmt,
             ));
-            _ = black_box(|| fmt.write_to(&mut sink));
+            _ = black_box(|| fmt.into_message().write_to(&mut sink));
         })
     });
 
@@ -165,9 +165,10 @@ fn benchmark_log_formatter(c: &mut Criterion) {
     let mut formatted = fmt.clone();
     eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut formatted);
 
+    let message = formatted.into_message();
     c.bench_function("log_formatter_write_only", |b| {
         b.iter(|| {
-            _ = black_box(|| formatted.write_to(&mut sink));
+            _ = black_box(|| message.write_to(&mut sink));
         })
     });
 }
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 8f25c103..9b028a0a 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -93,27 +93,6 @@ impl LogFormatter {
         Ok(LogFormatter { catalog: Arc::new(IndexedTemplate { templates, indices }), format })
     }
 
-    pub fn write_to<W: std::io::Write>(&self, w: &mut W) -> std::io::Result<usize> {
-        let mut total_bytes = 0;
-        for (_part, out) in self.catalog.templates.iter().zip(self.format.iter()) {
-            total_bytes += match out {
-                StringType::Smol(s) => IoWrite::write(w, s.as_bytes())?,
-                StringType::Char(c) => {
-                    let mut buf = [0u8; 4];
-                    let bytes = c.encode_utf8(&mut buf).as_bytes();
-                    IoWrite::write(w, bytes)?
-                },
-                // StringType::Compact(s) => IoWrite::write(w, s.as_bytes())?,
-                #[cfg(debug_assertions)]
-                _ => IoWrite::write(w, format!("%{:?}%", _part).as_bytes())?,
-                #[cfg(not(debug_assertions))]
-                _ => IoWrite::write(w, "?".as_bytes())?,
-            };
-        }
-
-        Ok(total_bytes)
-    }
-
     pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &Self {
         for idx in &self.catalog.indices[C::category() as usize] {
             unsafe {
@@ -126,22 +105,54 @@ impl LogFormatter {
         self
     }
 
+    #[inline]
+    pub fn into_message(self) -> FormattedMessage {
+        FormattedMessage { format: self.format }
+    }
+
     #[inline]
     pub fn is_fully_formatted(&self) -> bool {
         self.format.iter().all(|f| *f != StringType::None)
     }
 }
 
-impl Display for LogFormatter {
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
+pub struct FormattedMessage {
+    format: Vec<StringType>,
+}
+
+impl FormattedMessage {
+    #[inline]
+    pub fn is_fully_formatted(&self) -> bool {
+        self.format.iter().all(|f| *f != StringType::None)
+    }
+
+    pub fn write_to<W: std::io::Write>(&self, w: &mut W) -> std::io::Result<usize> {
+        let mut total_bytes = 0;
+        for out in self.format.iter() {
+            total_bytes += match out {
+                StringType::Smol(s) => IoWrite::write(w, s.as_bytes())?,
+                StringType::Char(c) => {
+                    let mut buf = [0u8; 4];
+                    let bytes = c.encode_utf8(&mut buf).as_bytes();
+                    IoWrite::write(w, bytes)?
+                },
+                // StringType::Compact(s) => IoWrite::write(w, s.as_bytes())?,
+                _ => IoWrite::write(w, "?".as_bytes())?,
+            };
+        }
+
+        Ok(total_bytes)
+    }
+}
+
+impl Display for FormattedMessage {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        for (_part, out) in self.catalog.templates.iter().zip(self.format.iter()) {
+        for out in self.format.iter() {
             match out {
                 StringType::Smol(s) => f.write_str(s.as_ref())?,
                 StringType::Char(c) => f.write_char(*c)?,
                 // StringType::Compact(s) => f.write_str(s.as_ref())?,
-                #[cfg(debug_assertions)]
-                _ => f.write_str(&format!("%{:?}%", _part))?,
-                #[cfg(not(debug_assertions))]
                 _ => f.write_str(&format!("?"))?,
             };
         }
@@ -187,7 +198,7 @@ mod tests {
         let expected = "/";
 
         formatter.with_context(&DownstreamRequest(&req));
-        let actual = format!("{}", &formatter);
+        let actual = format!("{}", &formatter.into_message());
         assert_eq!(actual, expected);
     }
 
@@ -201,7 +212,7 @@ mod tests {
         let expected = "/original";
 
         formatter.with_context(&DownstreamRequest(&req));
-        let actual = format!("{}", &formatter);
+        let actual = format!("{}", &formatter.into_message());
         assert_eq!(actual, expected);
     }
 
@@ -213,7 +224,7 @@ mod tests {
         println!("FORMATTER: {:?}", formatter);
         let expected = "GET";
         formatter.with_context(&DownstreamRequest(&req));
-        let actual = format!("{}", &formatter);
+        let actual = format!("{}", &formatter.into_message());
         assert_eq!(actual, expected);
     }
 
@@ -225,7 +236,7 @@ mod tests {
         println!("FORMATTER: {:?}", formatter);
         let expected = "HTTP/1.1";
         formatter.with_context(&DownstreamRequest(&req));
-        let actual = format!("{}", &formatter);
+        let actual = format!("{}", &formatter.into_message());
         assert_eq!(actual, expected);
     }
 
@@ -237,7 +248,7 @@ mod tests {
         println!("FORMATTER: {:?}", formatter);
         let expected = "HTTP/1.1";
         formatter.with_context(&UpstreamRequest(&req));
-        let actual = format!("{}", &formatter);
+        let actual = format!("{}", &formatter.into_message());
         assert_eq!(actual, expected);
     }
 
@@ -248,7 +259,7 @@ mod tests {
         let mut formatter = source.clone();
         let expected = "https";
         formatter.with_context(&DownstreamRequest(&req));
-        let actual = format!("{}", &formatter);
+        let actual = format!("{}", &formatter.into_message());
         assert_eq!(actual, expected);
     }
 
@@ -259,7 +270,7 @@ mod tests {
         let mut formatter = source.clone();
         let expected = "www.rust-lang.org";
         formatter.with_context(&DownstreamRequest(&req));
-        let actual = format!("{}", &formatter);
+        let actual = format!("{}", &formatter.into_message());
         assert_eq!(actual, expected);
     }
 
@@ -270,7 +281,7 @@ mod tests {
         let mut formatter = source.clone();
         let expected = "awesome/1.0";
         formatter.with_context(&DownstreamRequest(&req));
-        let actual = format!("{}", &formatter);
+        let actual = format!("{}", &formatter.into_message());
         assert_eq!(actual, expected);
     }
 
@@ -278,7 +289,7 @@ mod tests {
     fn test_unevaluated_operator() {
         let source = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
         let formatter = source.clone();
-        let actual = format!("{}", &formatter);
+        let actual = format!("{}", &formatter.into_message());
         println!("{actual}");
     }
 
@@ -299,6 +310,6 @@ mod tests {
             response_flags: ResponseFlags::NO_HEALTHY_UPSTREAM,
         });
         assert!(formatter.is_fully_formatted());
-        println!("{}", &source);
+        println!("{}", &source.into_message());
     }
 }

From bdf32da0622468ae54c3f05d831a1330dbc6e94b Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 23 May 2025 16:19:23 +0200
Subject: [PATCH 46/64] Fix formatting of DEFAULT_ENVOY_FORMAT string

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/lib.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 9b028a0a..be7d615c 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -16,7 +16,8 @@ use thiserror::Error;
 
 use crate::grammar::EnvoyGrammar;
 
-pub const DEFAULT_ENVOY_FORMAT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
+pub const DEFAULT_ENVOY_FORMAT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%"
+"#;
 
 #[derive(Error, Debug)]
 pub enum FormatError {

From b89ef05ba5cfd6c2fdedb338b9d17869e6b9a287 Mon Sep 17 00:00:00 2001
From: Alan Keane <alan.keane1@huawei.com>
Date: Fri, 23 May 2025 16:50:52 +0100
Subject: [PATCH 47/64] Update dependencies Cargo.lock to resolve audit issues

Signed-off-by: Alan Keane <alan.keane1@huawei.com>
---
 Cargo.lock | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index f5bdcc0b..c0ce2844 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3558,6 +3558,16 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
+dependencies = [
+ "windows-core",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.61.2"

From 2eb5e9235844d05e8359ed8807e38419ba8ebd7b Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 23 May 2025 17:58:34 +0200
Subject: [PATCH 48/64] Few minor clippy fixes.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/Cargo.toml             |  2 +-
 orion-format/benches/benchmark.rs   | 16 ++++++++--------
 orion-format/src/bin/format-test.rs | 14 ++++++++------
 orion-format/src/context.rs         | 14 +++++++-------
 orion-format/src/grammar.rs         | 26 ++++++++++++++++++--------
 orion-format/src/lib.rs             | 24 ++++++++++++++----------
 orion-format/src/types.rs           | 14 ++++----------
 7 files changed, 60 insertions(+), 50 deletions(-)

diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index db577712..254f298b 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -19,7 +19,7 @@ dhat = "0.3.3"
 bitflags = "2.9.0"
 itoa = "1.0.15"
 compact_str = "0.8.0"
-serde.workspace = true
+serde = { workspace = true, features = ["rc"] }
 http-serde-ext = "1.0.2"
 strum = { version = "0.27.1", features = ["derive"] }
 strum_macros = "0.27.1"
diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 88811f79..256a88e2 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -48,18 +48,18 @@ fn benchmark_rust_format(c: &mut Criterion) {
         response_flags: ResponseFlags::empty(),
     };
 
-    let default_haader_value = HeaderValue::from_static("");
+    let default_header_value = HeaderValue::from_static("");
     let upstream_host: String = "www.upstream.com".into();
 
     c.bench_function("rust_format!", |b| {
         b.iter(|| {
-            let start_time = start.start_time.clone();
+            let start_time = start.start_time;
             let datetime_utc: DateTime<Utc> = start_time.into();
             let rfc3339 = datetime_utc.to_rfc3339_opts(SecondsFormat::Millis, true);
 
             let method = request.method().clone();
             let uri = request.uri().clone();
-            let protocol = request.version().clone();
+            let protocol = request.version();
             let ver = match protocol {
                 Version::HTTP_10 => "HTTP/1.0",
                 Version::HTTP_11 => "HTTP/1.1",
@@ -68,14 +68,14 @@ fn benchmark_rust_format(c: &mut Criterion) {
                 _ => "HTTP/UNKNOWN",
             };
 
-            let response_code = response.status().clone();
+            let response_code = response.status();
             let end_context = end.clone();
 
             let x_envoy_upstream_service_time =
-                header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers(), &default_haader_value);
-            let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers(), &default_haader_value);
-            let user_agent = header_lookup("USER-AGENT", request.headers(), &default_haader_value);
-            let x_request_id = header_lookup("X-REQUEST-ID", request.headers(), &default_haader_value);
+                header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers(), &default_header_value);
+            let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers(), &default_header_value);
+            let user_agent = header_lookup("USER-AGENT", request.headers(), &default_header_value);
+            let x_request_id = header_lookup("X-REQUEST-ID", request.headers(), &default_header_value);
             let upstream_host = upstream_host.clone();
 
             let path: String = request
diff --git a/orion-format/src/bin/format-test.rs b/orion-format/src/bin/format-test.rs
index 60db8dd7..551e9090 100644
--- a/orion-format/src/bin/format-test.rs
+++ b/orion-format/src/bin/format-test.rs
@@ -25,14 +25,15 @@ where
 
 const TOTAL: u64 = 100_000_000;
 
-fn main() {
+type BoxError = Box<dyn std::error::Error + Send + Sync>;
+
+fn main() -> Result <(), BoxError> {
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")
         .header("User-Agent", "my-awesome-agent/1.0")
-        .body(())
-        .unwrap();
+        .body(())?;
 
-    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let response = Response::builder().status(StatusCode::OK).body(())?;
     let start = InitContext { start_time: std::time::SystemTime::now() };
     let end = FinishContext {
         duration: Duration::from_millis(100),
@@ -41,10 +42,10 @@ fn main() {
         response_flags: ResponseFlags::empty(),
     };
 
-    let fmt = LogFormatter::try_new(DEF_FMT).unwrap();
+    let fmt = LogFormatter::try_new(DEF_FMT)?;
     // let mut sink = std::io::sink();
 
-    println!("Running {} log format...", TOTAL);
+    println!("Running {TOTAL} log format...");
 
     let now = Instant::now();
 
@@ -61,4 +62,5 @@ fn main() {
         TOTAL as f64 / dur.as_secs_f64(),
         (dur.as_secs_f64() * 1_000_000_000.0) / TOTAL as f64
     );
+    Ok(())
 }
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 116ec85c..cbe3014c 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -39,11 +39,11 @@ pub struct UpstreamContext<'a> {
 #[derive(Clone, Debug)]
 pub struct DownstreamContext {}
 
-impl<'c> Context for UpstreamContext<'c> {
+impl Context for UpstreamContext<'_> {
     fn category() -> Category {
         Category::UpstreamContext
     }
-    fn eval_part<'a>(&'a self, op: &Operator) -> StringType {
+    fn eval_part(&self, op: &Operator) -> StringType {
         match op {
             Operator::UpstreamHost => StringType::Smol(SmolStr::new(self.authority.as_str())),
             _ => StringType::None,
@@ -93,7 +93,7 @@ pub struct UpstreamRequest<'a, T>(pub &'a Request<T>);
 pub struct DownstreamResponse<'a, T>(pub &'a Response<T>);
 pub struct UpstreamResponse<'a, T>(pub &'a Response<T>);
 
-impl<'a, T> Context for DownstreamRequest<'a, T> {
+impl<T> Context for DownstreamRequest<'_, T> {
     fn category() -> Category {
         Category::DownstreamRequest
     }
@@ -130,7 +130,7 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
                 let hv = self.0.headers().get(h);
                 match hv {
                     Some(hv) => {
-                        if let Some(s) = hv.to_str().ok() {
+                        if let Ok(s) = hv.to_str() {
                             StringType::Smol(SmolStr::new(s))
                         } else {
                             StringType::None
@@ -145,7 +145,7 @@ impl<'a, T> Context for DownstreamRequest<'a, T> {
     }
 }
 
-impl<'a, T> Context for UpstreamRequest<'a, T> {
+impl<T> Context for UpstreamRequest<'_, T> {
     fn category() -> Category {
         Category::UpstreamRequest
     }
@@ -157,7 +157,7 @@ impl<'a, T> Context for UpstreamRequest<'a, T> {
     }
 }
 
-impl<'a, T> Context for DownstreamResponse<'a, T> {
+impl<T> Context for DownstreamResponse<'_, T> {
     fn category() -> Category {
         Category::DownstreamResponse
     }
@@ -168,7 +168,7 @@ impl<'a, T> Context for DownstreamResponse<'a, T> {
                 let hv = self.0.headers().get(h.as_str());
                 match hv {
                     Some(hv) => {
-                        if let Some(s) = hv.to_str().ok() {
+                        if let Ok(s) = hv.to_str() {
                             StringType::Smol(SmolStr::new(s))
                         } else {
                             StringType::None
diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index fb6c50b1..a8f2f7aa 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -194,14 +194,14 @@ impl EnvoyGrammar {
 impl Grammar for EnvoyGrammar {
     fn parse(input: &str) -> Result<Vec<Template>, FormatError> {
         let mut parts = Vec::new();
-        let mut literal_start = 0; // Indice di inizio del literal corrente
+        let mut literal_start = 0;
         let mut i = 0;
 
         while i < input.len() {
             let mut longest_placeholder: Option<(Operator, Category, usize)> = None;
             let mut skip = None;
 
-            // finst the longest placeholder starting from the current index i
+            // find the longest placeholder starting from the current index i
             //
             if input[i..].starts_with('%') {
                 let remainder = &input[i + 1..];
@@ -215,7 +215,7 @@ impl Grammar for EnvoyGrammar {
                     if *has_arg {
                         let (arg_value, arg_len) = Self::extract_operator_arg(after_placeholder)?;
 
-                        if longest_placeholder.is_none() || *placeholder_len > longest_placeholder.as_ref().unwrap().2 {
+                        if longest_placeholder.as_ref().is_none_or(|(_, _, len)| *placeholder_len > *len) {
                             match placeholder {
                                 Operator::Request => {
                                     let token = Self::parse_request(arg_value)?;
@@ -253,7 +253,12 @@ impl Grammar for EnvoyGrammar {
                 if i > literal_start {
                     let literal_text = &input[literal_start..i];
                     if literal_text.chars().count() == 1 {
-                        parts.push(Template::Char(literal_text.chars().next().unwrap()));
+                        // if the literal is a single char, push it as a char
+                        if let Some(c) = literal_text.chars().next() {
+                            parts.push(Template::Char(c));
+                        } else { // This case should not happen, but just in case
+                            parts.push(Template::Literal(literal_text.into()));
+                        }
                     } else {
                         parts.push(Template::Literal(literal_text.into()));
                     }
@@ -266,13 +271,13 @@ impl Grammar for EnvoyGrammar {
                     placeholder.1,
                 ));
 
-                // advnace the index beyond the current placeholder and possibly its argument.
-                i += skip.unwrap();
+                // advance the index beyond the current placeholder and possibly its argument.
+                i += skip.unwrap_or(0);
 
                 literal_start = i;
             } else {
                 /* skip the specified number of bytes, or by default the next char */
-                i += skip.unwrap_or(input[i..].chars().next().map(|c| c.len_utf8()).unwrap_or(0));
+                i += skip.unwrap_or(input[i..].chars().next().map(char::len_utf8).unwrap_or(0));
             }
         }
 
@@ -280,7 +285,12 @@ impl Grammar for EnvoyGrammar {
         if i > literal_start {
             let literal_text = &input[literal_start..i].replace("%%", "%");
             if literal_text.chars().count() == 1 {
-                parts.push(Template::Char(literal_text.chars().next().unwrap()));
+                if let Some(c) = literal_text.chars().next() {
+                    // if the literal is a single char, push it as a char
+                    parts.push(Template::Char(c));
+                } else { // This case should not happen, but just in case
+                    parts.push(Template::Literal(literal_text.into()));
+                }
             } else {
                 parts.push(Template::Literal(literal_text.into()));
             }
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index be7d615c..fdacf9cc 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -66,7 +66,11 @@ pub struct LogFormatter {
 
 impl Default for LogFormatter {
     fn default() -> Self {
-        LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap()
+        if let Ok(log) = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT) {
+            log
+        } else {
+            panic!("Failed to create default LogFormatter")
+        }
     }
 }
 
@@ -94,11 +98,11 @@ impl LogFormatter {
         Ok(LogFormatter { catalog: Arc::new(IndexedTemplate { templates, indices }), format })
     }
 
-    pub fn with_context<'a, C: Context>(&mut self, ctx: &'a C) -> &Self {
+    pub fn with_context<C: Context>(&mut self, ctx: &C) -> &Self {
         for idx in &self.catalog.indices[C::category() as usize] {
             unsafe {
                 if let Template::Placeholder(op, _) = self.catalog.templates.get_unchecked(*idx as usize) {
-                    *self.format.get_unchecked_mut(*idx as usize) = ctx.eval_part(&op);
+                    *self.format.get_unchecked_mut(*idx as usize) = ctx.eval_part(op);
                 }
             }
         }
@@ -130,7 +134,7 @@ impl FormattedMessage {
 
     pub fn write_to<W: std::io::Write>(&self, w: &mut W) -> std::io::Result<usize> {
         let mut total_bytes = 0;
-        for out in self.format.iter() {
+        for out in &self.format {
             total_bytes += match out {
                 StringType::Smol(s) => IoWrite::write(w, s.as_bytes())?,
                 StringType::Char(c) => {
@@ -149,12 +153,12 @@ impl FormattedMessage {
 
 impl Display for FormattedMessage {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        for out in self.format.iter() {
+        for out in &self.format {
             match out {
                 StringType::Smol(s) => f.write_str(s.as_ref())?,
                 StringType::Char(c) => f.write_char(*c)?,
                 // StringType::Compact(s) => f.write_str(s.as_ref())?,
-                _ => f.write_str(&format!("?"))?,
+                _ => f.write_str("?")?,
             };
         }
         Ok(())
@@ -222,7 +226,7 @@ mod tests {
         let req = build_request();
         let source = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
         let mut formatter = source.clone();
-        println!("FORMATTER: {:?}", formatter);
+        println!("FORMATTER: {formatter:?}");
         let expected = "GET";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter.into_message());
@@ -234,7 +238,7 @@ mod tests {
         let req = build_request();
         let source = LogFormatter::try_new("%PROTOCOL%").unwrap();
         let mut formatter = source.clone();
-        println!("FORMATTER: {:?}", formatter);
+        println!("FORMATTER: {formatter:?}");
         let expected = "HTTP/1.1";
         formatter.with_context(&DownstreamRequest(&req));
         let actual = format!("{}", &formatter.into_message());
@@ -246,7 +250,7 @@ mod tests {
         let req = build_request();
         let source = LogFormatter::try_new("%UPSTREAM_PROTOCOL%").unwrap();
         let mut formatter = source.clone();
-        println!("FORMATTER: {:?}", formatter);
+        println!("FORMATTER: {formatter:?}");
         let expected = "HTTP/1.1";
         formatter.with_context(&UpstreamRequest(&req));
         let actual = format!("{}", &formatter.into_message());
@@ -302,7 +306,7 @@ mod tests {
         let mut formatter = source.clone();
         formatter.with_context(&InitContext { start_time: std::time::SystemTime::now() });
         formatter.with_context(&DownstreamRequest(&req));
-        formatter.with_context(&UpstreamContext { authority: &req.uri().authority().unwrap() });
+        formatter.with_context(&UpstreamContext { authority: req.uri().authority().unwrap() });
         formatter.with_context(&DownstreamResponse(&resp));
         formatter.with_context(&FinishContext {
             duration: Duration::from_millis(100),
diff --git a/orion-format/src/types.rs b/orion-format/src/types.rs
index 7e36fb9c..30f8ac4c 100644
--- a/orion-format/src/types.rs
+++ b/orion-format/src/types.rs
@@ -40,15 +40,14 @@ bitflags! {
 pub struct ResponseFlagsShort<'a>(pub &'a ResponseFlags);
 pub struct ResponseFlagsLong<'a>(pub &'a ResponseFlags);
 
-impl<'a> ToSmolStr for ResponseFlagsShort<'a> {
+impl ToSmolStr for ResponseFlagsShort<'_> {
     fn to_smolstr(&self) -> SmolStr {
         if self.0.is_empty() {
             return SmolStr::new_static("-");
         }
         let mut flags = SmolStrBuilder::new();
-        let mut i = 0;
 
-        for f in self.0.clone() {
+        for (i ,f) in self.0.clone().iter().enumerate() {
             if i > 0 {
                 flags.push(',');
             }
@@ -85,23 +84,20 @@ impl<'a> ToSmolStr for ResponseFlagsShort<'a> {
                 ResponseFlags::UNCONDITIONAL_DROP_OVERLOAD           => flags.push_str("UDO"),
                 _ => flags.push_str("?"),
             });
-
-            i += 1;
         }
 
         flags.finish()
     }
 }
 
-impl<'a> ToSmolStr for ResponseFlagsLong<'a> {
+impl ToSmolStr for ResponseFlagsLong<'_> {
     fn to_smolstr(&self) -> SmolStr {
         if self.0.is_empty() {
             return SmolStr::new_static("-");
         }
         let mut flags = SmolStrBuilder::new();
-        let mut i = 0;
 
-        for f in self.0.clone() {
+        for (i, f) in self.0.clone().iter().enumerate() {
             if i > 0 {
                 flags.push(',');
             }
@@ -138,8 +134,6 @@ impl<'a> ToSmolStr for ResponseFlagsLong<'a> {
                 ResponseFlags::UNCONDITIONAL_DROP_OVERLOAD           => flags.push_str("UnconditionalDropOverload"),
                 _ => flags.push_str("?"),
             });
-
-            i += 1;
         }
 
         flags.finish()

From 965948e326bc83e2bcdfc1871390fe1cf69202a6 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 26 May 2025 09:02:47 +0200
Subject: [PATCH 49/64] Update DownstreamRequest and DownstreamResponse to
 return "-" for None cases

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/context.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index cbe3014c..0680d944 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -136,7 +136,7 @@ impl<T> Context for DownstreamRequest<'_, T> {
                             StringType::None
                         }
                     },
-                    None => StringType::Smol(SmolStr::new_static("")),
+                    None => StringType::Smol(SmolStr::new_static("-")),
                 }
             },
             Operator::Protocol => StringType::Smol(SmolStr::new_static(into_protocol(self.0.version()))),
@@ -175,7 +175,7 @@ impl<T> Context for DownstreamResponse<'_, T> {
                         }
                     },
 
-                    None => StringType::Smol(SmolStr::new_static("")),
+                    None => StringType::Smol(SmolStr::new_static("-")),
                 }
             },
             _ => StringType::None,

From f7fac76221faee41c04bd1f656f04a1def851c83 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 26 May 2025 09:03:30 +0200
Subject: [PATCH 50/64] Implement UnwrapClippyWorkaround trait to replace
 unwrap calls with stealth_unwrap to avoid clippy warnings or errors  in
 benchmarks.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 58 +++++++++++++++++++++++--------
 1 file changed, 43 insertions(+), 15 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 256a88e2..c64b2d05 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -32,14 +32,42 @@ fn header_lookup<'a>(name: &'a str, m: &'a HeaderMap, default_header: &'a Header
     m.get(name).unwrap_or(default_header)
 }
 
+// A workaround for the `unwrap` lint in Clippy, which is too strict for our benchmarks.
+// This trait provides a method to unwrap `Option` and `Result` types without triggering Clippy warnings.
+trait UnwrapClippyWorkaround {
+    type Target;
+    fn stealth_unwrap(self) -> Self::Target;
+}
+
+impl<T> UnwrapClippyWorkaround for Option<T> {
+    type Target = T;
+
+    fn stealth_unwrap(self) -> Self::Target {
+        match self {
+            Some(value) => value,
+            None => panic!("Called stealth_unwrap on None"),
+        }
+    }
+}
+
+impl<T, E> UnwrapClippyWorkaround for Result<T, E> {
+    type Target = T;
+
+    fn stealth_unwrap(self) -> Self::Target {
+        match self {
+            Ok(value) => value,
+            _ => panic!("Called stealth_unwrap on Err"),
+        }
+    }
+}
 fn benchmark_rust_format(c: &mut Criterion) {
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")
         .header("User-Agent", "my-awesome-agent/1.0")
         .body(())
-        .unwrap();
+        .stealth_unwrap();
 
-    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let response = Response::builder().status(StatusCode::OK).body(()).stealth_unwrap();
     let start = InitContext { start_time: std::time::SystemTime::now() };
     let end = FinishContext {
         duration: Duration::from_millis(100),
@@ -96,11 +124,11 @@ fn benchmark_rust_format(c: &mut Criterion) {
                 end_context.bytes_received,
                 end_context.bytes_sent,
                 end_context.duration.as_millis(),
-                x_envoy_upstream_service_time.to_str().unwrap(),
-                x_forwarded_for.to_str().unwrap(),
-                user_agent.to_str().unwrap(),
-                x_request_id.to_str().unwrap(),
-                uri.authority().unwrap().host(),
+                x_envoy_upstream_service_time.to_str().stealth_unwrap(),
+                x_forwarded_for.to_str().stealth_unwrap(),
+                user_agent.to_str().stealth_unwrap(),
+                x_request_id.to_str().stealth_unwrap(),
+                uri.authority().stealth_unwrap().host(),
                 upstream_host,
             ));
         });
@@ -115,9 +143,9 @@ fn benchmark_log_formatter(c: &mut Criterion) {
         .uri("https://www.rust-lang.org/hello")
         .header("User-Agent", "my-awesome-agent/1.0")
         .body(())
-        .unwrap();
+        .stealth_unwrap();
 
-    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let response = Response::builder().status(StatusCode::OK).body(()).stealth_unwrap();
     let start = InitContext { start_time: std::time::SystemTime::now() };
     let end = FinishContext {
         duration: Duration::from_millis(100),
@@ -126,7 +154,7 @@ fn benchmark_log_formatter(c: &mut Criterion) {
         response_flags: ResponseFlags::empty(),
     };
 
-    let fmt = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).unwrap();
+    let fmt = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT).stealth_unwrap();
     let mut sink = std::io::sink();
 
     c.bench_function("log_formatter_full", |b| {
@@ -178,9 +206,9 @@ fn benchmark_request_parts(c: &mut Criterion) {
         .uri("https://www.rust-lang.org/hello")
         .header("User-Agent", "my-awesome-agent/1.0")
         .body(())
-        .unwrap();
+        .stealth_unwrap();
 
-    let response = Response::builder().status(StatusCode::OK).body(()).unwrap();
+    let response = Response::builder().status(StatusCode::OK).body(()).stealth_unwrap();
     let start = InitContext { start_time: std::time::SystemTime::now() };
     let end = FinishContext {
         duration: Duration::from_millis(100),
@@ -189,7 +217,7 @@ fn benchmark_request_parts(c: &mut Criterion) {
         response_flags: ResponseFlags::empty(),
     };
 
-    let fmt = LogFormatter::try_new("%REQ(:PATH)%").unwrap();
+    let fmt = LogFormatter::try_new("%REQ(:PATH)%").stealth_unwrap();
     c.bench_function("REQ(:PATH)", |b| {
         b.iter(|| {
             let mut fmt = fmt.clone();
@@ -197,7 +225,7 @@ fn benchmark_request_parts(c: &mut Criterion) {
         })
     });
 
-    let fmt = LogFormatter::try_new("%REQ(:METHOD)%").unwrap();
+    let fmt = LogFormatter::try_new("%REQ(:METHOD)%").stealth_unwrap();
     c.bench_function("REQ(:METHOD)", |b| {
         b.iter(|| {
             let mut fmt = fmt.clone();
@@ -205,7 +233,7 @@ fn benchmark_request_parts(c: &mut Criterion) {
         })
     });
 
-    let fmt = LogFormatter::try_new("%REQ(USER-AGENT)%").unwrap();
+    let fmt = LogFormatter::try_new("%REQ(USER-AGENT)%").stealth_unwrap();
     c.bench_function("REQ(USER-AGENT)", |b| {
         b.iter(|| {
             let mut fmt = fmt.clone();

From e5b7e186503c8110587754a4cef107832bd5783e Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 26 May 2025 10:02:00 +0200
Subject: [PATCH 51/64] Additional clippy adjustments.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/bin/format-test.rs |  4 ++--
 orion-format/src/grammar.rs         | 37 ++++++++++++++---------------
 orion-format/src/lib.rs             | 17 ++++++-------
 3 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/orion-format/src/bin/format-test.rs b/orion-format/src/bin/format-test.rs
index 551e9090..dcb22538 100644
--- a/orion-format/src/bin/format-test.rs
+++ b/orion-format/src/bin/format-test.rs
@@ -10,7 +10,7 @@ use std::time::{Duration, Instant};
 const DEF_FMT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%""#;
 
 #[inline]
-fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter)
+fn eval_format<C1, C2, C3, C4>(req: &C1, resp: &C2, start: &C3, end: &C4, fmt: &mut LogFormatter) -> bool
 where
     C1: Context,
     C2: Context,
@@ -21,6 +21,7 @@ where
     fmt.with_context(resp);
     fmt.with_context(start);
     fmt.with_context(end);
+    true
 }
 
 const TOTAL: u64 = 100_000_000;
@@ -52,7 +53,6 @@ fn main() -> Result <(), BoxError> {
     for _ in 0..TOTAL {
         let mut fmt = black_box(fmt.clone());
         black_box(eval_format(&DownstreamRequest(&request), &DownstreamResponse(&response), &start, &end, &mut fmt));
-        // _ = black_box(|| fmt_.write_to(&mut sink));
     }
 
     let dur = now.elapsed();
diff --git a/orion-format/src/grammar.rs b/orion-format/src/grammar.rs
index a8f2f7aa..ea816de7 100644
--- a/orion-format/src/grammar.rs
+++ b/orion-format/src/grammar.rs
@@ -25,8 +25,7 @@ lazy_static! {
     };
 
     static ref ENVOY_RESP_ARGS: Trie<u8, (Operator, Category, usize, bool)> = {
-        let trie = Trie::new();
-        trie
+        Trie::new()
     };
 
     static ref ENVOY_PATTERNS: Trie<u8, (Operator, Category, usize, bool)> = {
@@ -155,24 +154,22 @@ pub struct EnvoyGrammar;
 
 impl EnvoyGrammar {
     fn parse_request(arg: &str) -> Result<Operator, FormatError> {
-        match ENVOY_REQ_ARGS.find_longest_prefix(arg.bytes()) {
-            Some((t, _, _, _)) => Ok(t.clone()),
-            None => {
-                let name =
-                    HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidRequestArg(arg.into()))?;
-                Ok(Operator::RequestStandard(name))
-            },
+        if let Some((t, _, _, _)) = ENVOY_REQ_ARGS.find_longest_prefix(arg.bytes()) {
+            Ok(t.clone())
+        } else {
+            let name =
+                HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidRequestArg(arg.into()))?;
+            Ok(Operator::RequestStandard(name))
         }
     }
 
     fn parse_response(arg: &str) -> Result<Operator, FormatError> {
-        match ENVOY_RESP_ARGS.find_longest_prefix(arg.bytes()) {
-            Some((t, _, _, _)) => Ok(t.clone()),
-            None => {
-                let name =
-                    HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidResponseArg(arg.into()))?;
-                Ok(Operator::ResponseStandard(name))
-            },
+        if let Some((t, _, _, _)) = ENVOY_RESP_ARGS.find_longest_prefix(arg.bytes()) {
+            Ok(t.clone())
+        } else {
+            let name =
+                HeaderName::from_bytes(arg.as_bytes()).map_err(|_| FormatError::InvalidResponseArg(arg.into()))?;
+            Ok(Operator::ResponseStandard(name))
         }
     }
 
@@ -256,7 +253,8 @@ impl Grammar for EnvoyGrammar {
                         // if the literal is a single char, push it as a char
                         if let Some(c) = literal_text.chars().next() {
                             parts.push(Template::Char(c));
-                        } else { // This case should not happen, but just in case
+                        } else {
+                            // This case should not happen, but just in case
                             parts.push(Template::Literal(literal_text.into()));
                         }
                     } else {
@@ -281,14 +279,15 @@ impl Grammar for EnvoyGrammar {
             }
         }
 
-        // if there's some text remaning, it's a literal
+        // if there's some text remaining, it's a literal
         if i > literal_start {
             let literal_text = &input[literal_start..i].replace("%%", "%");
             if literal_text.chars().count() == 1 {
                 if let Some(c) = literal_text.chars().next() {
                     // if the literal is a single char, push it as a char
                     parts.push(Template::Char(c));
-                } else { // This case should not happen, but just in case
+                } else {
+                    // This case should not happen, but just in case
                     parts.push(Template::Literal(literal_text.into()));
                 }
             } else {
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index fdacf9cc..13fd2bdd 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -35,6 +35,9 @@ pub enum FormatError {
     InvalidRequestArg(String),
     #[error("invalid response argument `{0}`")]
     InvalidResponseArg(String),
+
+    #[error("invalid operator index `{0}`")]
+    InvalidOperatorIndex(#[from] std::num::TryFromIntError),
 }
 
 #[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
@@ -81,17 +84,17 @@ impl LogFormatter {
 
         for (i, part) in templates.iter().enumerate() {
             if let Template::Placeholder(_, category) = part {
-                indices[*category as usize].push(i as u8);
+                indices[*category as usize].push(u8::try_from(i)?);
             }
         }
 
         let mut format: Vec<StringType> = Vec::with_capacity(templates.len());
 
-        for t in templates.iter() {
+        for t in &templates {
             match t {
                 Template::Char(c) => format.push(StringType::Char(*c)),
                 Template::Literal(smol_str) => format.push(StringType::Smol(smol_str.clone())),
-                _ => format.push(StringType::None),
+                Template::Placeholder(_,_) => format.push(StringType::None),
             }
         }
 
@@ -142,8 +145,7 @@ impl FormattedMessage {
                     let bytes = c.encode_utf8(&mut buf).as_bytes();
                     IoWrite::write(w, bytes)?
                 },
-                // StringType::Compact(s) => IoWrite::write(w, s.as_bytes())?,
-                _ => IoWrite::write(w, "?".as_bytes())?,
+                StringType::None => IoWrite::write(w, "?".as_bytes())?, // this corresponds to an operator not evaluated from contexts
             };
         }
 
@@ -157,9 +159,8 @@ impl Display for FormattedMessage {
             match out {
                 StringType::Smol(s) => f.write_str(s.as_ref())?,
                 StringType::Char(c) => f.write_char(*c)?,
-                // StringType::Compact(s) => f.write_str(s.as_ref())?,
-                _ => f.write_str("?")?,
-            };
+                StringType::None => f.write_str("?")?,
+            }
         }
         Ok(())
     }

From c00a81c4822ecad6f76b1b5710419a31139b4b86 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 26 May 2025 10:30:37 +0200
Subject: [PATCH 52/64] Update cargo fmt.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/bin/format-test.rs | 2 +-
 orion-format/src/lib.rs             | 2 +-
 orion-format/src/types.rs           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/orion-format/src/bin/format-test.rs b/orion-format/src/bin/format-test.rs
index dcb22538..79f0cf86 100644
--- a/orion-format/src/bin/format-test.rs
+++ b/orion-format/src/bin/format-test.rs
@@ -28,7 +28,7 @@ const TOTAL: u64 = 100_000_000;
 
 type BoxError = Box<dyn std::error::Error + Send + Sync>;
 
-fn main() -> Result <(), BoxError> {
+fn main() -> Result<(), BoxError> {
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")
         .header("User-Agent", "my-awesome-agent/1.0")
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 13fd2bdd..3d7a60cb 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -94,7 +94,7 @@ impl LogFormatter {
             match t {
                 Template::Char(c) => format.push(StringType::Char(*c)),
                 Template::Literal(smol_str) => format.push(StringType::Smol(smol_str.clone())),
-                Template::Placeholder(_,_) => format.push(StringType::None),
+                Template::Placeholder(_, _) => format.push(StringType::None),
             }
         }
 
diff --git a/orion-format/src/types.rs b/orion-format/src/types.rs
index 30f8ac4c..4d59a039 100644
--- a/orion-format/src/types.rs
+++ b/orion-format/src/types.rs
@@ -47,7 +47,7 @@ impl ToSmolStr for ResponseFlagsShort<'_> {
         }
         let mut flags = SmolStrBuilder::new();
 
-        for (i ,f) in self.0.clone().iter().enumerate() {
+        for (i, f) in self.0.clone().iter().enumerate() {
             if i > 0 {
                 flags.push(',');
             }

From aab957060080610bee6c60ce3e4d4a2a9ad3dc62 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 26 May 2025 12:48:39 +0200
Subject: [PATCH 53/64] Update DownstreamRequest and DownstreamResponse to
 return "-" for None cases and add Bytes variant to StringType

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/context.rs | 18 ++++++++----------
 orion-format/src/lib.rs     |  3 +++
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 0680d944..f24fe9a3 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -114,7 +114,7 @@ impl<T> Context for DownstreamRequest<'_, T> {
                 if let Some(a) = extract_authority_from_request(self.0) {
                     StringType::Smol(SmolStr::new(a))
                 } else {
-                    StringType::None
+                    StringType::Smol(SmolStr::new_static("-"))
                 }
             },
             Operator::RequestMethod => StringType::Smol(SmolStr::new(self.0.method().as_str())),
@@ -122,7 +122,7 @@ impl<T> Context for DownstreamRequest<'_, T> {
                 if let Some(s) = self.0.uri().scheme() {
                     StringType::Smol(SmolStr::new(s.as_str()))
                 } else {
-                    StringType::None
+                    StringType::Smol(SmolStr::new_static("-"))
                 }
             },
 
@@ -130,10 +130,9 @@ impl<T> Context for DownstreamRequest<'_, T> {
                 let hv = self.0.headers().get(h);
                 match hv {
                     Some(hv) => {
-                        if let Ok(s) = hv.to_str() {
-                            StringType::Smol(SmolStr::new(s))
-                        } else {
-                            StringType::None
+                        match String::from_utf8_lossy(hv.as_bytes()) {
+                            std::borrow::Cow::Borrowed(s) => StringType::Smol(SmolStr::new(s)),
+                            std::borrow::Cow::Owned(s) => StringType::Smol(SmolStr::new(s)),
                         }
                     },
                     None => StringType::Smol(SmolStr::new_static("-")),
@@ -168,10 +167,9 @@ impl<T> Context for DownstreamResponse<'_, T> {
                 let hv = self.0.headers().get(h.as_str());
                 match hv {
                     Some(hv) => {
-                        if let Ok(s) = hv.to_str() {
-                            StringType::Smol(SmolStr::new(s))
-                        } else {
-                            StringType::None
+                        match String::from_utf8_lossy(hv.as_bytes()) {
+                            std::borrow::Cow::Borrowed(s) => StringType::Smol(SmolStr::new(s)),
+                            std::borrow::Cow::Owned(s) => StringType::Smol(SmolStr::new(s)),
                         }
                     },
 
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 3d7a60cb..65a56d64 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -51,6 +51,7 @@ pub enum Template {
 pub enum StringType {
     Char(char),
     Smol(SmolStr),
+    Bytes(Box<[u8]>),
     // Compact(CompactString),
     None,
 }
@@ -145,6 +146,7 @@ impl FormattedMessage {
                     let bytes = c.encode_utf8(&mut buf).as_bytes();
                     IoWrite::write(w, bytes)?
                 },
+                StringType::Bytes(bs) => IoWrite::write(w, bs)?,
                 StringType::None => IoWrite::write(w, "?".as_bytes())?, // this corresponds to an operator not evaluated from contexts
             };
         }
@@ -159,6 +161,7 @@ impl Display for FormattedMessage {
             match out {
                 StringType::Smol(s) => f.write_str(s.as_ref())?,
                 StringType::Char(c) => f.write_char(*c)?,
+                StringType::Bytes(bs) => f.write_str(&String::from_utf8_lossy(bs))?,
                 StringType::None => f.write_str("?")?,
             }
         }

From 51d61a2984babf7c8abd7880d8efa3b9c33fd5d9 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 26 May 2025 13:06:01 +0200
Subject: [PATCH 54/64] Update for cargo fmt.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/context.rs | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index f24fe9a3..2881af14 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -129,11 +129,9 @@ impl<T> Context for DownstreamRequest<'_, T> {
             Operator::RequestStandard(h) => {
                 let hv = self.0.headers().get(h);
                 match hv {
-                    Some(hv) => {
-                        match String::from_utf8_lossy(hv.as_bytes()) {
-                            std::borrow::Cow::Borrowed(s) => StringType::Smol(SmolStr::new(s)),
-                            std::borrow::Cow::Owned(s) => StringType::Smol(SmolStr::new(s)),
-                        }
+                    Some(hv) => match String::from_utf8_lossy(hv.as_bytes()) {
+                        std::borrow::Cow::Borrowed(s) => StringType::Smol(SmolStr::new(s)),
+                        std::borrow::Cow::Owned(s) => StringType::Smol(SmolStr::new(s)),
                     },
                     None => StringType::Smol(SmolStr::new_static("-")),
                 }
@@ -166,11 +164,9 @@ impl<T> Context for DownstreamResponse<'_, T> {
             Operator::ResponseStandard(h) => {
                 let hv = self.0.headers().get(h.as_str());
                 match hv {
-                    Some(hv) => {
-                        match String::from_utf8_lossy(hv.as_bytes()) {
-                            std::borrow::Cow::Borrowed(s) => StringType::Smol(SmolStr::new(s)),
-                            std::borrow::Cow::Owned(s) => StringType::Smol(SmolStr::new(s)),
-                        }
+                    Some(hv) => match String::from_utf8_lossy(hv.as_bytes()) {
+                        std::borrow::Cow::Borrowed(s) => StringType::Smol(SmolStr::new(s)),
+                        std::borrow::Cow::Owned(s) => StringType::Smol(SmolStr::new(s)),
                     },
 
                     None => StringType::Smol(SmolStr::new_static("-")),

From 581c18cd1477a41eb3595114fdaa9e3876f15b7f Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Mon, 26 May 2025 15:42:37 +0200
Subject: [PATCH 55/64] Refactor header value handling to use either strings or
 bytes.

Replaced `String::from_utf8_lossy` with `to_str` for header value
processing.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/src/context.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index 2881af14..b0fba466 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -129,9 +129,9 @@ impl<T> Context for DownstreamRequest<'_, T> {
             Operator::RequestStandard(h) => {
                 let hv = self.0.headers().get(h);
                 match hv {
-                    Some(hv) => match String::from_utf8_lossy(hv.as_bytes()) {
-                        std::borrow::Cow::Borrowed(s) => StringType::Smol(SmolStr::new(s)),
-                        std::borrow::Cow::Owned(s) => StringType::Smol(SmolStr::new(s)),
+                    Some(hv) => match hv.to_str() {
+                        Ok(s) => StringType::Smol(SmolStr::new(s)),
+                        Err(_) => StringType::Bytes(hv.as_bytes().to_vec().into_boxed_slice()),
                     },
                     None => StringType::Smol(SmolStr::new_static("-")),
                 }
@@ -164,9 +164,9 @@ impl<T> Context for DownstreamResponse<'_, T> {
             Operator::ResponseStandard(h) => {
                 let hv = self.0.headers().get(h.as_str());
                 match hv {
-                    Some(hv) => match String::from_utf8_lossy(hv.as_bytes()) {
-                        std::borrow::Cow::Borrowed(s) => StringType::Smol(SmolStr::new(s)),
-                        std::borrow::Cow::Owned(s) => StringType::Smol(SmolStr::new(s)),
+                    Some(hv) => match hv.to_str() {
+                        Ok(s) => StringType::Smol(SmolStr::new(s)),
+                        Err(_) => StringType::Bytes(hv.as_bytes().to_vec().into_boxed_slice()),
                     },
 
                     None => StringType::Smol(SmolStr::new_static("-")),

From b6951b1f1ef1a7a6323d889198ca6c43b6046ced Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Tue, 27 May 2025 10:37:04 +0200
Subject: [PATCH 56/64] Add benchmark for log headers and improve error
 messages

- Introduced `benchmark_log_headers` to test log header formatting.
- Fixed typo in error message: "braket" -> "bracket".
- Simplified `StringType::Bytes` handling by unconditinally use Box<[u8]> and removing redundant conversions.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-format/benches/benchmark.rs | 89 +++++++++++++++++++++++++++++--
 orion-format/src/context.rs       | 35 +++++-------
 orion-format/src/lib.rs           | 30 ++++++++---
 3 files changed, 120 insertions(+), 34 deletions(-)

diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index c64b2d05..908aac0f 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -50,16 +50,20 @@ impl<T> UnwrapClippyWorkaround for Option<T> {
     }
 }
 
-impl<T, E> UnwrapClippyWorkaround for Result<T, E> {
+impl<T, E> UnwrapClippyWorkaround for Result<T, E>
+where
+    E: std::fmt::Display,
+{
     type Target = T;
 
     fn stealth_unwrap(self) -> Self::Target {
         match self {
             Ok(value) => value,
-            _ => panic!("Called stealth_unwrap on Err"),
+            Err(e) => panic!("Called stealth_unwrap on Err({e})"),
         }
     }
 }
+
 fn benchmark_rust_format(c: &mut Criterion) {
     let request = Request::builder()
         .uri("https://www.rust-lang.org/hello")
@@ -101,7 +105,7 @@ fn benchmark_rust_format(c: &mut Criterion) {
 
             let x_envoy_upstream_service_time =
                 header_lookup("X-ENVOY-UPSTREAM-SERVICE-TIME", request.headers(), &default_header_value);
-            let x_forwarded_for = header_lookup("SX-FORWARDED-FORER-AGENT", request.headers(), &default_header_value);
+            let x_forwarded_for = header_lookup("X-FORWARDED-FOR", request.headers(), &default_header_value);
             let user_agent = header_lookup("USER-AGENT", request.headers(), &default_header_value);
             let x_request_id = header_lookup("X-REQUEST-ID", request.headers(), &default_header_value);
             let upstream_host = upstream_host.clone();
@@ -242,6 +246,83 @@ fn benchmark_request_parts(c: &mut Criterion) {
     });
 }
 
-criterion_group!(benches, benchmark_rust_format, benchmark_log_formatter, benchmark_request_parts);
+fn benchmark_log_headers(c: &mut Criterion) {
+    #[cfg(feature = "dhat-heap")]
+    let _profiler = dhat::Profiler::new_heap();
+
+    let request = Request::builder()
+        .uri("https://www.rust-lang.org/hello")
+        .header("X-Header-0", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-1", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-2", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-3", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-4", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-5", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-6", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-7", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-8", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-9", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-10", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-11", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-12", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-13", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-14", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-15", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-16", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-17", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-18", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-19", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-20", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-21", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-23", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-24", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-25", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-26", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-27", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-28", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-29", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-30", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-31", "XXXXXXXXXXXXXXXXXXXX")
+        .header("X-Header-32", "XXXXXXXXXXXXXXXXXXXX")
+        .body(())
+        .stealth_unwrap();
+
+    const ENVOY_FORMAT: &str = r#"%REQ(X-Header-0)% %REQ(X-Header-1)% %REQ(X-Header-2)% %REQ(X-Header-3)% %REQ(X-Header-4)% %REQ(X-Header-5)% %REQ(X-Header-6)% %REQ(X-Header-7)% %REQ(X-Header-8)% %REQ(X-Header-9)%
+     %REQ(X-Header-10)% %REQ(X-Header-11)% %REQ(X-Header-12)% %REQ(X-Header-13)% %REQ(X-Header-14)% %REQ(X-Header-15)% %REQ(X-Header-16)% %REQ(X-Header-17)% %REQ(X-Header-18)% %REQ(X-Header-19)% %REQ(X-Header-20)%
+     %REQ(X-Header-21)% %REQ(X-Header-22)% %REQ(X-Header-23)% %REQ(X-Header-24)% %REQ(X-Header-25)% %REQ(X-Header-26)% %REQ(X-Header-27)% %REQ(X-Header-28)% %REQ(X-Header-29)% %REQ(X-Header-30)% %REQ(X-Header-31)%
+     %REQ(X-Header-32)%"#;
+
+    let response = Response::builder().status(StatusCode::OK).body(()).stealth_unwrap();
+    let start = InitContext { start_time: std::time::SystemTime::now() };
+    let end = FinishContext {
+        duration: Duration::from_millis(100),
+        bytes_received: 128,
+        bytes_sent: 256,
+        response_flags: ResponseFlags::empty(),
+    };
+
+    let fmt = LogFormatter::try_new(ENVOY_FORMAT).stealth_unwrap();
+
+    c.bench_function("log_format_headers", |b| {
+        b.iter(|| {
+            let mut fmt = fmt.clone();
+            black_box(eval_format(
+                &DownstreamRequest(&request),
+                &DownstreamResponse(&response),
+                &start,
+                &end,
+                &mut fmt,
+            ));
+        })
+    });
+}
+
+criterion_group!(
+    benches,
+    benchmark_rust_format,
+    benchmark_log_formatter,
+    benchmark_log_headers,
+    benchmark_request_parts
+);
 
 criterion_main!(benches);
diff --git a/orion-format/src/context.rs b/orion-format/src/context.rs
index b0fba466..dca3c3db 100644
--- a/orion-format/src/context.rs
+++ b/orion-format/src/context.rs
@@ -1,7 +1,6 @@
 use std::time::{Duration, SystemTime};
 
 use chrono::{DateTime, Datelike, Timelike, Utc};
-// use compact_str::CompactString;
 use http::{uri::Authority, HeaderName, Request, Response, Version};
 use smol_str::{SmolStr, SmolStrBuilder, ToSmolStr};
 
@@ -57,7 +56,6 @@ impl Context for InitContext {
     }
     fn eval_part(&self, op: &Operator) -> StringType {
         match op {
-            // Operator::StartTime => StringType::Compact(format_system_time_compact(self.start_time)),
             Operator::StartTime => StringType::Smol(format_system_time(self.start_time)),
             _ => StringType::None,
         }
@@ -129,10 +127,7 @@ impl<T> Context for DownstreamRequest<'_, T> {
             Operator::RequestStandard(h) => {
                 let hv = self.0.headers().get(h);
                 match hv {
-                    Some(hv) => match hv.to_str() {
-                        Ok(s) => StringType::Smol(SmolStr::new(s)),
-                        Err(_) => StringType::Bytes(hv.as_bytes().to_vec().into_boxed_slice()),
-                    },
+                    Some(hv) => StringType::Bytes(hv.as_bytes().into()),
                     None => StringType::Smol(SmolStr::new_static("-")),
                 }
             },
@@ -164,11 +159,7 @@ impl<T> Context for DownstreamResponse<'_, T> {
             Operator::ResponseStandard(h) => {
                 let hv = self.0.headers().get(h.as_str());
                 match hv {
-                    Some(hv) => match hv.to_str() {
-                        Ok(s) => StringType::Smol(SmolStr::new(s)),
-                        Err(_) => StringType::Bytes(hv.as_bytes().to_vec().into_boxed_slice()),
-                    },
-
+                    Some(hv) => StringType::Bytes(hv.as_bytes().into()),
                     None => StringType::Smol(SmolStr::new_static("-")),
                 }
             },
@@ -197,6 +188,17 @@ const TWO_DIGITS: [&str; 100] = [
     "95", "96", "97", "98", "99",
 ];
 
+#[inline]
+fn into_protocol(ver: Version) -> &'static str {
+    match ver {
+        Version::HTTP_10 => "HTTP/1.0",
+        Version::HTTP_11 => "HTTP/1.1",
+        Version::HTTP_2 => "HTTP/2",
+        Version::HTTP_3 => "HTTP/3",
+        _ => "HTTP/UNKNOWN",
+    }
+}
+
 pub fn format_system_time(time: SystemTime) -> SmolStr {
     let datetime: DateTime<Utc> = time.into();
 
@@ -221,17 +223,6 @@ pub fn format_system_time(time: SystemTime) -> SmolStr {
     builder.finish()
 }
 
-#[inline]
-fn into_protocol(ver: Version) -> &'static str {
-    match ver {
-        Version::HTTP_10 => "HTTP/1.0",
-        Version::HTTP_11 => "HTTP/1.1",
-        Version::HTTP_2 => "HTTP/2",
-        Version::HTTP_3 => "HTTP/3",
-        _ => "HTTP/UNKNOWN",
-    }
-}
-
 #[cfg(any())]
 pub fn format_system_time_heapless(time: SystemTime) -> heapless::String<24> {
     let datetime: DateTime<Utc> = time.into();
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 65a56d64..86e1da31 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -3,7 +3,7 @@ pub mod grammar;
 pub mod operator;
 pub mod types;
 
-// use compact_str::CompactString;
+use crate::grammar::EnvoyGrammar;
 use context::Context;
 use operator::{Category, Operator};
 use serde::{Deserialize, Serialize};
@@ -14,8 +14,6 @@ use std::sync::Arc;
 use strum::EnumCount;
 use thiserror::Error;
 
-use crate::grammar::EnvoyGrammar;
-
 pub const DEFAULT_ENVOY_FORMAT: &str = r#"[%START_TIME%] "%REQ(:METHOD)% %REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% %PROTOCOL%" %RESPONSE_CODE% %RESPONSE_FLAGS% %BYTES_RECEIVED% %BYTES_SENT% %DURATION% %RESP(X-ENVOY-UPSTREAM-SERVICE-TIME)% "%REQ(X-FORWARDED-FOR)%" "%REQ(USER-AGENT)%" "%REQ(X-REQUEST-ID)%" "%REQ(:AUTHORITY)%" "%UPSTREAM_HOST%"
 "#;
 
@@ -25,7 +23,7 @@ pub enum FormatError {
     InvalidOperator(String),
     #[error("missing argument `{0}`")]
     MissingArgument(String),
-    #[error("missing braket `{0}`")]
+    #[error("missing bracket `{0}`")]
     MissingBracket(String),
     #[error("missing delimiter `{0}`")]
     MissingDelimiter(String),
@@ -52,7 +50,6 @@ pub enum StringType {
     Char(char),
     Smol(SmolStr),
     Bytes(Box<[u8]>),
-    // Compact(CompactString),
     None,
 }
 
@@ -123,6 +120,16 @@ impl LogFormatter {
     pub fn is_fully_formatted(&self) -> bool {
         self.format.iter().all(|f| *f != StringType::None)
     }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.format.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.format.is_empty()
+    }
 }
 
 #[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
@@ -146,7 +153,7 @@ impl FormattedMessage {
                     let bytes = c.encode_utf8(&mut buf).as_bytes();
                     IoWrite::write(w, bytes)?
                 },
-                StringType::Bytes(bs) => IoWrite::write(w, bs)?,
+                StringType::Bytes(v) => IoWrite::write(w, v.as_ref())?,
                 StringType::None => IoWrite::write(w, "?".as_bytes())?, // this corresponds to an operator not evaluated from contexts
             };
         }
@@ -161,7 +168,7 @@ impl Display for FormattedMessage {
             match out {
                 StringType::Smol(s) => f.write_str(s.as_ref())?,
                 StringType::Char(c) => f.write_char(*c)?,
-                StringType::Bytes(bs) => f.write_str(&String::from_utf8_lossy(bs))?,
+                StringType::Bytes(v) => f.write_str(&String::from_utf8_lossy(v))?,
                 StringType::None => f.write_str("?")?,
             }
         }
@@ -319,6 +326,13 @@ mod tests {
             response_flags: ResponseFlags::NO_HEALTHY_UPSTREAM,
         });
         assert!(formatter.is_fully_formatted());
-        println!("{}", &source.into_message());
+        println!("{}", &formatter.into_message());
+    }
+
+    #[test]
+    fn test_sizes() {
+        println!("Vec:       {}", std::mem::size_of::<Vec<u8>>());
+        println!("SmolStr:   {}", std::mem::size_of::<SmolStr>());
+        println!("Box<[u8]>: {}", std::mem::size_of::<Box<[u8]>>());
     }
 }

From d43f3a29631256f6330f7eb34f6a831d177412a0 Mon Sep 17 00:00:00 2001
From: Alan Keane <alan.keane1@huawei.com>
Date: Thu, 29 May 2025 09:19:23 +0000
Subject: [PATCH 57/64] Websocket Support

Signed-off-by: Alan Keane <alan.keane1@huawei.com>
---
 .gitignore                                    |   1 +
 .../http_connection_manager.rs                | 249 +++++++++++++++++-
 .../http_connection_manager/route.rs          | 110 +++++++-
 orion-lib/src/clusters/cluster.rs             |   6 +-
 orion-lib/src/clusters/clusters_manager.rs    |   2 +-
 orion-lib/src/clusters/load_assignment.rs     |   4 +-
 orion-lib/src/listeners/filterchain.rs        |   2 +-
 .../src/listeners/http_connection_manager.rs  |  41 ++-
 .../http_connection_manager/route.rs          |   2 +-
 .../http_connection_manager/upgrade.rs        | 113 ++++++++
 orion-lib/src/listeners/listener.rs           |   2 +-
 .../src/listeners/synthetic_http_response.rs  |  28 ++
 orion-proxy/conf/envoy-bootstrap-dyn.yaml     | 137 ++++++++++
 13 files changed, 659 insertions(+), 38 deletions(-)
 create mode 100644 orion-lib/src/listeners/http_connection_manager/upgrade.rs
 create mode 100644 orion-proxy/conf/envoy-bootstrap-dyn.yaml

diff --git a/.gitignore b/.gitignore
index d6a8c164..0f00098d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 /target
+advisory-db
 .idea/
 *.profraw
 *~
diff --git a/orion-configuration/src/config/network_filters/http_connection_manager.rs b/orion-configuration/src/config/network_filters/http_connection_manager.rs
index 66d3743d..117da12c 100644
--- a/orion-configuration/src/config/network_filters/http_connection_manager.rs
+++ b/orion-configuration/src/config/network_filters/http_connection_manager.rs
@@ -21,16 +21,17 @@
 pub mod header_modifer;
 use header_modifer::{HeaderModifier, HeaderValueOption};
 pub mod header_matcher;
-use header_matcher::HeaderMatcher;
+use header_matcher::{HeaderMatcher, HeaderNames};
+
 pub mod route;
-use route::{Action, RouteMatch};
+use route::{Action, Connect, DirectResponseAction, RouteAction, RouteMatch, UpgradeAction, UpgradeActionType};
 pub mod http_filters;
 use http_filters::{FilterOverride, HttpFilter};
 
-use crate::config::common::*;
+use crate::config::{common::*, core::StringMatcher};
 use compact_str::CompactString;
 use exponential_backoff::Backoff;
-use http::{HeaderName, HeaderValue, StatusCode};
+use http::{header, HeaderName, HeaderValue, StatusCode};
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, str::FromStr, time::Duration};
 
@@ -42,6 +43,8 @@ pub struct HttpConnectionManager {
     pub request_timeout: Option<Duration>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub http_filters: Vec<HttpFilter>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub enabled_upgrades: Vec<UpgradeType>,
     pub route_specifier: RouteSpecifier,
 }
 
@@ -55,6 +58,14 @@ pub enum CodecType {
     Http2,
 }
 
+#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)]
+pub enum UpgradeType {
+    #[serde(rename = "websocket")]
+    Websocket,
+    #[serde(rename = "connect")]
+    Connect,
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 #[serde(untagged)]
 pub enum RouteSpecifier {
@@ -77,6 +88,16 @@ pub struct RouteConfiguration {
     pub virtual_hosts: Vec<VirtualHost>,
 }
 
+impl RouteConfiguration {
+    pub fn expand_routes(&mut self, hcm_enabled_upgrades: &[UpgradeType]) {
+        for virtual_host in &mut self.virtual_hosts {
+            let expanded_routes =
+                virtual_host.routes.iter().flat_map(|route| route.unfold_upgrades(hcm_enabled_upgrades)).collect();
+            virtual_host.routes = expanded_routes;
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum MatchHost {
     Wildcard,
@@ -340,13 +361,106 @@ pub struct Route {
     pub request_headers_to_remove: Vec<HeaderName>,
     #[serde(rename = "match")]
     pub route_match: RouteMatch,
-    //todo(hayley): fix this field. Is it used correctly? key is name in higher level filter. value is overwrite (append-overwrite?)
     #[serde(skip_serializing_if = "HashMap::is_empty", default = "Default::default")]
     pub typed_per_filter_config: std::collections::HashMap<CompactString, FilterOverride>,
     #[serde(flatten)]
     pub action: Action,
 }
 
+impl Route {
+    fn connect_matcher() -> HeaderMatcher {
+        HeaderMatcher {
+            header_name: HeaderNames::Method,
+            invert_match: false,
+            treat_missing_header_as_empty: false,
+            header_matcher: StringMatcher {
+                ignore_case: true,
+                pattern: crate::config::core::StringMatcherPattern::Exact("CONNECT".into()),
+            },
+        }
+    }
+    fn connection_header_matcher() -> HeaderMatcher {
+        HeaderMatcher {
+            header_name: HeaderNames::NormalHeader(header::CONNECTION),
+            invert_match: false,
+            treat_missing_header_as_empty: false,
+            header_matcher: StringMatcher {
+                ignore_case: true,
+                pattern: crate::config::core::StringMatcherPattern::Contains("upgrade".into()),
+            },
+        }
+    }
+    fn upgrade_header_matcher_for(upgrade_type: CompactString) -> HeaderMatcher {
+        HeaderMatcher {
+            header_name: HeaderNames::NormalHeader(header::UPGRADE),
+            invert_match: false,
+            treat_missing_header_as_empty: false,
+            header_matcher: StringMatcher {
+                ignore_case: true,
+                pattern: crate::config::core::StringMatcherPattern::Exact(upgrade_type),
+            },
+        }
+    }
+    pub fn unfold_upgrades(&self, hcm_enabled_upgrades: &[UpgradeType]) -> Vec<Route> {
+        match &self.action {
+            Action::Route(RouteAction {
+                cluster_specifier,
+                cluster_not_found_response_code,
+                rewrite,
+                upgrade_config,
+                ..
+            }) => {
+                let mut routes = Vec::new();
+                let mut ws_route = self.clone();
+                ws_route.route_match.headers.extend(vec![
+                    Route::connection_header_matcher(),
+                    Route::upgrade_header_matcher_for("websocket".into()),
+                ]);
+                if upgrade_config.is_some_and(|cfg| cfg.is_websocket_enabled(hcm_enabled_upgrades)) {
+                    let handler = UpgradeAction {
+                        cluster_specifier: cluster_specifier.clone(),
+                        cluster_not_found_response_code: *cluster_not_found_response_code,
+                        rewrite: rewrite.clone(),
+                        upgrade_type: UpgradeActionType::Websocket,
+                    };
+                    ws_route.action = Action::Upgrade(handler);
+                } else {
+                    let handler = DirectResponseAction { status: StatusCode::UPGRADE_REQUIRED, body: None };
+                    ws_route.action = Action::DirectResponse(handler);
+                }
+                routes.push(ws_route);
+
+                let mut connect_route = self.clone();
+                connect_route.route_match.headers.insert(0, Route::connect_matcher());
+                if upgrade_config.is_some_and(|cfg| cfg.is_connect_enabled(hcm_enabled_upgrades)) {
+                    let connect_ctx = upgrade_config
+                        .and_then(|cfg| cfg.connect)
+                        .and_then(|connect| match connect {
+                            Connect::Enabled { allow_post } => Some(UpgradeActionType::Connect { allow_post }),
+                            Connect::Disabled => None,
+                        })
+                        .unwrap_or(UpgradeActionType::Connect { allow_post: false });
+                    let handler = UpgradeAction {
+                        cluster_specifier: cluster_specifier.clone(),
+                        cluster_not_found_response_code: *cluster_not_found_response_code,
+                        rewrite: rewrite.clone(),
+                        upgrade_type: connect_ctx,
+                    };
+                    connect_route.action = Action::Upgrade(handler);
+                } else {
+                    let handler = DirectResponseAction { status: StatusCode::FORBIDDEN, body: None };
+                    connect_route.action = Action::DirectResponse(handler);
+                }
+                routes.push(connect_route);
+
+                routes.push(self.clone());
+                routes
+            },
+            _ => vec![self.clone()],
+        }
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 pub struct RdsSpecifier {
     pub route_config_name: CompactString,
@@ -365,7 +479,12 @@ pub enum ConfigSourceSpecifier {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use crate::config::cluster::ClusterSpecifier;
+
+    use super::{
+        route::{PathMatcher, UpgradeConfig},
+        *,
+    };
     use std::str::FromStr;
 
     #[inline]
@@ -526,6 +645,103 @@ mod tests {
         assert!(MatchHostScoreLPM::Wildcard < MatchHostScoreLPM::Suffix("foo.bar.test.com".len()));
         assert!(MatchHostScoreLPM::Wildcard == MatchHostScoreLPM::Wildcard);
     }
+
+    #[test]
+    fn test_unfold_upgrades() {
+        let route_a = Route {
+            response_header_modifier: HeaderModifier::default(),
+            request_headers_to_add: vec![],
+            request_headers_to_remove: vec![],
+            route_match: RouteMatch {
+                path_matcher: Some(PathMatcher {
+                    specifier: route::PathSpecifier::Exact("/chat".into()),
+                    ignore_case: true,
+                }),
+                headers: vec![HeaderMatcher {
+                    header_name: HeaderNames::NormalHeader(HeaderName::from_static("my-header")),
+                    invert_match: false,
+                    treat_missing_header_as_empty: false,
+                    header_matcher: StringMatcher {
+                        ignore_case: true,
+                        pattern: crate::config::core::StringMatcherPattern::Exact("value".into()),
+                    },
+                }],
+            },
+            typed_per_filter_config: std::collections::HashMap::<CompactString, FilterOverride>::new(),
+            action: Action::Route(RouteAction {
+                cluster_specifier: ClusterSpecifier::Cluster("cluster-a".into()),
+                cluster_not_found_response_code: StatusCode::NOT_FOUND,
+                timeout: None,
+                rewrite: None,
+                retry_policy: None,
+                upgrade_config: Some(UpgradeConfig { websocket: Some(route::Websocket::Enabled), connect: None }),
+                hash_policy: vec![],
+            }),
+        };
+        let routes_a = route_a.unfold_upgrades(&vec![]);
+        assert_eq!(routes_a.len(), 3);
+        match routes_a.as_slice() {
+            [ws_upgrade_route, reject_connect_route, vanilla_http_route] => {
+                assert!(
+                    matches!(ws_upgrade_route.action, Action::Upgrade(_)),
+                    "expected first route to handle the ws upgrade"
+                );
+                assert_eq!(
+                    ws_upgrade_route.route_match.headers.len(),
+                    vanilla_http_route.route_match.headers.len() + 2,
+                    "expected additional header checks in ws upgrade route matcher"
+                );
+                assert!(
+                    matches!(reject_connect_route.action, Action::DirectResponse(_)),
+                    "expected second route to reject CONNECT requests"
+                );
+                assert_eq!(
+                    vanilla_http_route, &route_a,
+                    "expected to retain original http route when derving upgrade route matchers"
+                );
+            },
+            _ => panic!("expected three dervied routes"),
+        }
+        let route_b = Route {
+            route_match: RouteMatch {
+                path_matcher: Some(PathMatcher {
+                    specifier: route::PathSpecifier::Exact("/interesting".into()),
+                    ignore_case: true,
+                }),
+                headers: vec![],
+            },
+            action: Action::Route(RouteAction {
+                cluster_specifier: ClusterSpecifier::Cluster("cluster-a".into()),
+                cluster_not_found_response_code: StatusCode::NOT_FOUND,
+                timeout: None,
+                rewrite: None,
+                retry_policy: None,
+                upgrade_config: None,
+                hash_policy: vec![],
+            }),
+            ..route_a.clone()
+        };
+        let routes_b = route_b.unfold_upgrades(&vec![UpgradeType::Connect]);
+        assert_eq!(routes_b.len(), 3);
+        match routes_b.as_slice() {
+            [ws_reject_route, connect_matcher, vanilla_http_route] => {
+                assert!(
+                    matches!(ws_reject_route.action, Action::DirectResponse(_)),
+                    "expected first route to reject WS upgrades"
+                );
+                assert_eq!(
+                    connect_matcher.route_match.headers.len(),
+                    vanilla_http_route.route_match.headers.len() + 1,
+                    "expected a special header matcher to detect connect method"
+                );
+                assert_eq!(
+                    vanilla_http_route, &route_b,
+                    "expected to retain original http route when derving the connec upgrade matcher"
+                );
+            },
+            _ => panic!("expected three dervied routes"),
+        }
+    }
 }
 
 #[cfg(feature = "envoy-conversions")]
@@ -538,7 +754,7 @@ mod envoy_conversions {
             SupportedEnvoyHttpFilter,
         },
         CodecType, ConfigSource, ConfigSourceSpecifier, HttpConnectionManager, RdsSpecifier, RetryBackoff, RetryOn,
-        RetryPolicy, Route, RouteConfiguration, RouteSpecifier, VirtualHost,
+        RetryPolicy, Route, RouteConfiguration, RouteSpecifier, UpgradeType, VirtualHost,
     };
     use crate::config::{
         common::*,
@@ -683,7 +899,7 @@ mod envoy_conversions {
                 set_current_client_cert_details,
                 proxy_100_continue,
                 represent_ipv4_remote_address_as_ipv4_mapped_ipv6,
-                upgrade_configs,
+                // upgrade_configs,
                 normalize_path,
                 merge_slashes,
                 path_with_escaped_slashes_action,
@@ -714,6 +930,10 @@ mod envoy_conversions {
                 .transpose()
                 .map_err(|_| GenericError::from_msg("failed to convert into Duration"))
                 .with_node("request_timeout")?;
+            let enabled_upgrades = upgrade_configs
+                .iter()
+                .map(|upgrade_config| upgrade_config.upgrade_type.clone().try_into())
+                .collect::<Result<Vec<UpgradeType>, _>>()?;
             let mut http_filters: Vec<SupportedEnvoyHttpFilter> = convert_non_empty_vec!(http_filters)?;
             match http_filters.pop() {
                 Some(SupportedEnvoyHttpFilter { filter: SupportedEnvoyFilter::Router(rtr), name, disabled: false }) => {
@@ -754,7 +974,7 @@ mod envoy_conversions {
                     }
                 }
             }
-            Ok(Self { codec_type, http_filters, route_specifier, request_timeout })
+            Ok(Self { codec_type, http_filters, enabled_upgrades, route_specifier, request_timeout })
         }
     }
 
@@ -777,6 +997,17 @@ mod envoy_conversions {
         }
     }
 
+    impl TryFrom<String> for UpgradeType {
+        type Error = GenericError;
+        fn try_from(s: String) -> Result<Self, Self::Error> {
+            match s.to_lowercase().as_str() {
+                "websocket" => Ok(UpgradeType::Websocket),
+                "connect" => Err(GenericError::from_msg("Http CONNECT upgrades are not currently supported")),
+                s => Err(GenericError::from_msg(format!("Unsupported upgrade type [{s}]"))),
+            }
+        }
+    }
+
     // In the original Protobuf specification, this enum is `oneof` rds, route_config or scoped_routes,
     // this is why the name of the field is manually added in case an error happens.
     impl TryFrom<Option<EnvoyRouteSpecifier>> for RouteSpecifier {
diff --git a/orion-configuration/src/config/network_filters/http_connection_manager/route.rs b/orion-configuration/src/config/network_filters/http_connection_manager/route.rs
index c56ff027..07a77215 100644
--- a/orion-configuration/src/config/network_filters/http_connection_manager/route.rs
+++ b/orion-configuration/src/config/network_filters/http_connection_manager/route.rs
@@ -18,7 +18,7 @@
 //
 //
 
-use super::{header_matcher::HeaderMatcher, RetryPolicy};
+use super::{header_matcher::HeaderMatcher, RetryPolicy, UpgradeType};
 use crate::config::{
     cluster::ClusterSpecifier,
     common::*,
@@ -48,6 +48,7 @@ pub enum Action {
     Route(RouteAction),
     DirectResponse(DirectResponseAction),
     Redirect(RedirectAction),
+    Upgrade(UpgradeAction),
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
@@ -220,6 +221,25 @@ impl Eq for DirectResponseBody {}
 
 //todo: impl serialize, deserialize on DirectResponsebody to prepare the bytes at deserialization
 
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+pub enum UpgradeActionType {
+    Websocket,
+    Connect { allow_post: bool /* , proxy_protocol_config: Option<...> */ },
+}
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+pub struct UpgradeAction {
+    pub cluster_specifier: ClusterSpecifier,
+    #[serde(
+        with = "http_serde_ext::status_code",
+        skip_serializing_if = "is_default_statuscode",
+        default = "default_statuscode_deser"
+    )]
+    pub cluster_not_found_response_code: StatusCode,
+    #[serde(skip_serializing_if = "Option::is_none", default = "Default::default")]
+    pub rewrite: Option<PathRewriteSpecifier>,
+    pub upgrade_type: UpgradeActionType,
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 pub struct RouteAction {
     pub cluster_specifier: ClusterSpecifier,
@@ -235,9 +255,9 @@ pub struct RouteAction {
     #[serde(skip_serializing_if = "Option::is_none", default = "Default::default")]
     pub rewrite: Option<PathRewriteSpecifier>,
     #[serde(skip_serializing_if = "Option::is_none", default = "Default::default")]
-    //note(hayley): we wrap this struct in an Arc because orion-lib is designed around that.
-    // ideally we would check if we could instead use a referenve in orion-lib but that's a large refactor
     pub retry_policy: Option<RetryPolicy>,
+    #[serde(skip_serializing_if = "Option::is_none", default = "Default::default")]
+    pub upgrade_config: Option<UpgradeConfig>,
     #[serde(skip_serializing_if = "Vec::is_empty", default = "Default::default")]
     pub hash_policy: Vec<HashPolicy>,
 }
@@ -260,6 +280,41 @@ fn is_default_timeout(timeout: &Option<Duration>) -> bool {
     *timeout == default_timeout_deser()
 }
 
+#[derive(Clone, Debug, Copy, Deserialize, Serialize, PartialEq, Eq)]
+pub enum Websocket {
+    Enabled,
+    Disabled,
+}
+
+#[derive(Clone, Debug, Copy, Deserialize, Serialize, PartialEq, Eq)]
+pub enum Connect {
+    Enabled { allow_post: bool /* , proxy_protocol_config: Option<...> */ },
+    Disabled,
+}
+
+#[derive(Clone, Debug, Copy, Default, Deserialize, Serialize, PartialEq, Eq)]
+pub struct UpgradeConfig {
+    #[serde(skip_serializing_if = "Option::is_none", default = "Default::default")]
+    pub websocket: Option<Websocket>,
+    #[serde(skip_serializing_if = "Option::is_none", default = "Default::default")]
+    pub connect: Option<Connect>,
+}
+
+impl UpgradeConfig {
+    pub fn is_websocket_enabled(&self, inherited: &[UpgradeType]) -> bool {
+        let enabled_via_hcm = inherited.iter().any(|upgrade| matches!(upgrade, UpgradeType::Websocket));
+        let locally_enabled = matches!(self.websocket, Some(Websocket::Enabled));
+        let locally_disabled = matches!(self.websocket, Some(Websocket::Disabled));
+        locally_enabled || (enabled_via_hcm && !locally_disabled)
+    }
+    pub fn is_connect_enabled(&self, inherited: &[UpgradeType]) -> bool {
+        let enabled_via_hcm = inherited.iter().any(|upgrade| matches!(upgrade, UpgradeType::Connect));
+        let locally_enabled = matches!(self.connect, Some(Connect::Enabled { allow_post: _ }));
+        let locally_disabled = matches!(self.connect, Some(Connect::Disabled));
+        locally_enabled || (enabled_via_hcm && !locally_disabled)
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 pub struct HashPolicy {
     pub policy_specifier: PolicySpecifier,
@@ -370,9 +425,9 @@ impl RouteMatch {
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 pub struct PathMatcher {
     #[serde(flatten)]
-    specifier: PathSpecifier,
+    pub specifier: PathSpecifier,
     #[serde(skip_serializing_if = "std::ops::Not::not", default = "Default::default")]
-    ignore_case: bool,
+    pub ignore_case: bool,
 }
 
 pub struct PathMatcherResult {
@@ -473,9 +528,9 @@ mod tests {
 mod envoy_conversions {
     #![allow(deprecated)]
     use super::{
-        Action, AuthorityRedirect, DirectResponseAction, DirectResponseBody, HashPolicy, PathMatcher,
+        Action, AuthorityRedirect, Connect, DirectResponseAction, DirectResponseBody, HashPolicy, PathMatcher,
         PathRewriteSpecifier, PathSpecifier, PolicySpecifier, RedirectAction, RedirectResponseCode,
-        RegexMatchAndSubstitute, RouteAction, RouteMatch, DEFAULT_TIMEOUT,
+        RegexMatchAndSubstitute, RouteAction, RouteMatch, UpgradeConfig, Websocket, DEFAULT_TIMEOUT,
     };
     use crate::config::network_filters::http_connection_manager::RetryPolicy;
     use crate::config::{
@@ -499,7 +554,7 @@ mod envoy_conversions {
                     ConnectionProperties as EnvoyConnectionProperties, Header as EnvoyHeader,
                     PolicySpecifier as EnvoyPolicySpecifier, QueryParameter as EnvoyQueryParameter,
                 },
-                HashPolicy as EnvoyHashPolicy,
+                HashPolicy as EnvoyHashPolicy, UpgradeConfig as EnvoyUpgradeConfig,
             },
             route_match::PathSpecifier as EnvoyPathSpecifier,
             DirectResponseAction as EnvoyDirectResponseAction, RedirectAction as EnvoyRedirectAction,
@@ -507,6 +562,7 @@ mod envoy_conversions {
         },
         r#type::matcher::v3::RegexMatchAndSubstitute as EnvoyRegexMatchAndSubstitute,
     };
+    use ng2_data_plane_api::envoy_data_plane_api::google::protobuf::BoolValue;
     use std::{num::NonZeroU16, str::FromStr};
 
     impl TryFrom<EnvoyHashPolicy> for HashPolicy {
@@ -718,7 +774,7 @@ mod envoy_conversions {
                 cors,
                 max_grpc_timeout,
                 grpc_timeout_offset,
-                upgrade_configs,
+                // upgrade_configs,
                 internal_redirect_policy,
                 internal_redirect_action,
                 max_internal_redirects,
@@ -750,8 +806,42 @@ mod envoy_conversions {
                 },
             };
             let retry_policy = retry_policy.map(RetryPolicy::try_from).transpose().with_node("retry_policy")?;
+            let upgrade_config = upgrade_configs.try_into().with_node("upgrade_configs").ok();
             let hash_policy = convert_vec!(hash_policy)?;
-            Ok(Self { cluster_not_found_response_code, timeout, cluster_specifier, rewrite, retry_policy, hash_policy })
+            Ok(Self {
+                cluster_not_found_response_code,
+                timeout,
+                cluster_specifier,
+                rewrite,
+                retry_policy,
+                upgrade_config,
+                hash_policy,
+            })
+        }
+    }
+
+    impl TryFrom<Vec<EnvoyUpgradeConfig>> for UpgradeConfig {
+        type Error = GenericError;
+        fn try_from(value: Vec<EnvoyUpgradeConfig>) -> Result<Self, Self::Error> {
+            let mut upgrade_config = UpgradeConfig::default();
+            for envoy_upgrade_config in value {
+                match (envoy_upgrade_config.upgrade_type.to_lowercase().as_str(), envoy_upgrade_config.enabled) {
+                    ("websocket", Some(BoolValue { value: true })) => {
+                        upgrade_config.websocket = Some(Websocket::Enabled)
+                    },
+                    ("websocket", Some(BoolValue { value: false })) => {
+                        upgrade_config.websocket = Some(Websocket::Disabled)
+                    },
+                    ("connect", Some(BoolValue { value: true })) => {
+                        return Err(GenericError::from_msg("Http CONNECT upgrades are not currently supported"))
+                    },
+                    ("connect", Some(BoolValue { value: false })) => upgrade_config.connect = Some(Connect::Disabled),
+                    (unknown, _) => {
+                        return Err(GenericError::from_msg(format!("Unsupported upgrade type [{unknown}]")))
+                    },
+                }
+            }
+            Ok(upgrade_config)
         }
     }
 
diff --git a/orion-lib/src/clusters/cluster.rs b/orion-lib/src/clusters/cluster.rs
index a46b8f49..d88c17a1 100644
--- a/orion-lib/src/clusters/cluster.rs
+++ b/orion-lib/src/clusters/cluster.rs
@@ -164,7 +164,7 @@ pub trait ClusterOps {
     fn all_grpc_channels(&self) -> Vec<Result<(Authority, GrpcService)>>;
     fn change_tls_context(&mut self, secret_id: &str, secret: TransportSecret) -> Result<()>;
     fn update_health(&mut self, endpoint: &http::uri::Authority, health: HealthStatus);
-    fn get_http_connection(&mut self, lb_hash: HashState) -> Result<HttpChannel>;
+    fn get_http_connection(&mut self, lb_hash: Option<HashState>) -> Result<HttpChannel>;
     fn get_tcp_connection(&mut self) -> Result<BoxFuture<'static, std::result::Result<TcpStream, ConnectError>>>;
     fn get_grpc_connection(&mut self) -> Result<GrpcService>;
 }
@@ -252,7 +252,7 @@ impl ClusterOps for DynamicCluster {
         }
     }
 
-    fn get_http_connection(&mut self, lb_hash: HashState) -> Result<HttpChannel> {
+    fn get_http_connection(&mut self, lb_hash: Option<HashState>) -> Result<HttpChannel> {
         if let Some(cla) = self.load_assignment.as_mut() {
             cla.get_http_channel(lb_hash)
         } else {
@@ -315,7 +315,7 @@ impl ClusterOps for StaticCluster {
         self.load_assignment.update_endpoint_health(endpoint, health);
     }
 
-    fn get_http_connection(&mut self, lb_hash: HashState) -> Result<HttpChannel> {
+    fn get_http_connection(&mut self, lb_hash: Option<HashState>) -> Result<HttpChannel> {
         debug!("{} : Getting connection", self.name);
         self.load_assignment.get_http_channel(lb_hash)
     }
diff --git a/orion-lib/src/clusters/clusters_manager.rs b/orion-lib/src/clusters/clusters_manager.rs
index 5705cbf5..32763e55 100644
--- a/orion-lib/src/clusters/clusters_manager.rs
+++ b/orion-lib/src/clusters/clusters_manager.rs
@@ -138,7 +138,7 @@ pub fn remove_cluster(cluster_name: &str) -> Result<()> {
     CLUSTERS_MAP.update(|current| current.remove(cluster_name).map(|_| ()).ok_or("No such cluster".into()))
 }
 
-pub fn get_http_connection(selector: &ClusterSpecifierConfig, lb_hash: HashState) -> Result<HttpChannel> {
+pub fn get_http_connection(selector: &ClusterSpecifierConfig, lb_hash: Option<HashState>) -> Result<HttpChannel> {
     debug!("Http connection for {selector:?}");
     with_cluster_selector(selector, |cluster| cluster.get_http_connection(lb_hash))
 }
diff --git a/orion-lib/src/clusters/load_assignment.rs b/orion-lib/src/clusters/load_assignment.rs
index 1029b3e8..d25ef857 100644
--- a/orion-lib/src/clusters/load_assignment.rs
+++ b/orion-lib/src/clusters/load_assignment.rs
@@ -350,8 +350,8 @@ pub struct PartialClusterLoadAssignment {
 }
 
 impl ClusterLoadAssignment {
-    pub fn get_http_channel(&mut self, hash: HashState) -> Result<HttpChannel> {
-        let endpoint = self.balancer.next_item(Some(hash)).ok_or("No active endpoint")?;
+    pub fn get_http_channel(&mut self, hash: Option<HashState>) -> Result<HttpChannel> {
+        let endpoint = self.balancer.next_item(hash).ok_or("No active endpoint")?;
         Ok(endpoint.http_channel.clone())
     }
 
diff --git a/orion-lib/src/listeners/filterchain.rs b/orion-lib/src/listeners/filterchain.rs
index d9d67bf4..329a1cb4 100644
--- a/orion-lib/src/listeners/filterchain.rs
+++ b/orion-lib/src/listeners/filterchain.rs
@@ -209,7 +209,7 @@ impl FilterchainType {
                     CodecType::Auto => hyper_server,
                 };
                 hyper_server
-                    .serve_connection(
+                    .serve_connection_with_upgrades(
                         stream,
                         hyper::service::service_fn(|req: Request<hyper::body::Incoming>| {
                             let handler_req = HttpHandlerRequest { request: req, source_addr: peer_addr };
diff --git a/orion-lib/src/listeners/http_connection_manager.rs b/orion-lib/src/listeners/http_connection_manager.rs
index 2b99fe80..24675a14 100644
--- a/orion-lib/src/listeners/http_connection_manager.rs
+++ b/orion-lib/src/listeners/http_connection_manager.rs
@@ -21,7 +21,9 @@
 mod direct_response;
 mod redirect;
 mod route;
+mod upgrade;
 use route::MatchedRequest;
+use upgrade::UpgradeRequestContext;
 
 use crate::{
     body::timeout_body::TimeoutBody,
@@ -36,7 +38,7 @@ use orion_configuration::config::network_filters::http_connection_manager::{
     http_filters::{http_rbac::HttpRbac, HttpFilter as HttpFilterConfig, HttpFilterType},
     route::Action,
     CodecType, ConfigSource, ConfigSourceSpecifier, HttpConnectionManager as HttpConnectionManagerConfig, RdsSpecifier,
-    RouteSpecifier,
+    RouteSpecifier, UpgradeType,
 };
 use std::{
     fmt,
@@ -66,8 +68,14 @@ impl HttpConnectionManagerBuilder {
     pub fn build(self) -> Result<HttpConnectionManager> {
         let name = self.listener_name.ok_or("listener name is not set")?;
 
-        let PartialHttpConnectionManager { router, codec_type, dynamic_route_name, http_filters, request_timeout } =
-            self.connection_manager;
+        let PartialHttpConnectionManager {
+            router,
+            codec_type,
+            dynamic_route_name,
+            http_filters,
+            enabled_upgrades,
+            request_timeout,
+        } = self.connection_manager;
 
         let router_sender = watch::Sender::new(router.map(Arc::new));
 
@@ -77,6 +85,7 @@ impl HttpConnectionManagerBuilder {
             codec_type,
             dynamic_route_name,
             http_filters,
+            enabled_upgrades,
             request_timeout,
         })
     }
@@ -92,6 +101,7 @@ pub struct PartialHttpConnectionManager {
     codec_type: CodecType,
     dynamic_route_name: Option<CompactString>,
     http_filters: Vec<HttpFilter>,
+    enabled_upgrades: Vec<UpgradeType>,
     request_timeout: Option<Duration>,
 }
 
@@ -139,7 +149,7 @@ impl TryFrom<ConversionContext<'_, HttpConnectionManagerConfig>> for PartialHttp
     fn try_from(ctx: ConversionContext<HttpConnectionManagerConfig>) -> Result<Self> {
         let ConversionContext { envoy_object: configuration, secret_manager: _ } = ctx;
         let codec_type = configuration.codec_type;
-
+        let enabled_upgrades = configuration.enabled_upgrades;
         let http_filters = configuration.http_filters.into_iter().map(HttpFilter::from).collect();
         let request_timeout = configuration.request_timeout;
 
@@ -153,7 +163,14 @@ impl TryFrom<ConversionContext<'_, HttpConnectionManagerConfig>> for PartialHttp
             RouteSpecifier::RouteConfig(config) => (None, Some(config)),
         };
 
-        Ok(PartialHttpConnectionManager { router, codec_type, dynamic_route_name, http_filters, request_timeout })
+        Ok(PartialHttpConnectionManager {
+            router,
+            codec_type,
+            dynamic_route_name,
+            http_filters,
+            enabled_upgrades,
+            request_timeout,
+        })
     }
 }
 
@@ -191,6 +208,7 @@ pub struct HttpConnectionManager {
     pub codec_type: CodecType,
     dynamic_route_name: Option<CompactString>,
     http_filters: Vec<HttpFilter>,
+    enabled_upgrades: Vec<UpgradeType>,
     request_timeout: Option<Duration>,
 }
 
@@ -205,8 +223,9 @@ impl HttpConnectionManager {
         self.dynamic_route_name.as_ref()
     }
 
-    pub fn update_route(&self, route: Arc<RouteConfiguration>) {
-        let _ = self.router_sender.send_replace(Some(route));
+    pub fn update_route(&self, mut route: RouteConfiguration) {
+        route.expand_routes(&self.enabled_upgrades);
+        let _ = self.router_sender.send_replace(Some(Arc::new(route)));
     }
 
     pub fn remove_route(&self) {
@@ -238,9 +257,6 @@ impl RequestHandler<(Request<TimeoutBody<Incoming>>, SocketAddr)> for Arc<RouteC
         self,
         (request, source_address): (Request<TimeoutBody<Incoming>>, SocketAddr),
     ) -> Result<Response<PolyBody>> {
-        // needs some way to resolve the request first, _then_ apply modifications on both request and response from there
-        // might just want to implement this whole thing as a hyper service "layer"
-
         let Some(chosen_vh) = self
             .virtual_hosts
             .iter()
@@ -274,6 +290,11 @@ impl RequestHandler<(Request<TimeoutBody<Incoming>>, SocketAddr)> for Arc<RouteC
                     })
                     .await
             },
+            Action::Upgrade(handler) => {
+                handler
+                    .to_response(UpgradeRequestContext { request, route_match: route_match_result, source_address })
+                    .await
+            },
         }?;
         let resp_headers = response.headers_mut();
         if self.most_specific_header_mutations_wins {
diff --git a/orion-lib/src/listeners/http_connection_manager/route.rs b/orion-lib/src/listeners/http_connection_manager/route.rs
index af53d650..94ec06d6 100644
--- a/orion-lib/src/listeners/http_connection_manager/route.rs
+++ b/orion-lib/src/listeners/http_connection_manager/route.rs
@@ -51,7 +51,7 @@ impl<'a> RequestHandler<MatchedRequest<'a>> for &RouteAction {
         // > The router filter will place the original path before rewrite into the x-envoy-original-path header.
 
         let hash_state = HashState::new(&self.hash_policy, &request, source_address);
-        let maybe_channel = clusters_manager::get_http_connection(&self.cluster_specifier, hash_state);
+        let maybe_channel = clusters_manager::get_http_connection(&self.cluster_specifier, Some(hash_state));
         match maybe_channel {
             Ok(svc_channel) => {
                 let ver = request.version();
diff --git a/orion-lib/src/listeners/http_connection_manager/upgrade.rs b/orion-lib/src/listeners/http_connection_manager/upgrade.rs
new file mode 100644
index 00000000..69e0aba3
--- /dev/null
+++ b/orion-lib/src/listeners/http_connection_manager/upgrade.rs
@@ -0,0 +1,113 @@
+use super::RequestHandler;
+use crate::{
+    body::timeout_body::TimeoutBody,
+    clusters::{balancers::hash_policy::HashState, clusters_manager},
+    listeners::synthetic_http_response::SyntheticHttpResponse,
+    transport::request_context::RequestWithContext,
+    PolyBody, Result,
+};
+use http::{uri::Parts as UriParts, StatusCode, Uri, Version};
+use hyper::{body::Incoming, Request, Response};
+use hyper_util::rt::TokioIo;
+use orion_configuration::config::network_filters::http_connection_manager::route::{
+    RouteMatchResult, UpgradeAction, UpgradeActionType,
+};
+use orion_error::Context;
+use std::net::SocketAddr;
+use tokio::io::copy_bidirectional;
+use tracing::{debug, error};
+
+pub struct UpgradeRequestContext {
+    pub request: Request<TimeoutBody<Incoming>>,
+    pub route_match: RouteMatchResult,
+    pub source_address: SocketAddr,
+}
+
+impl RequestHandler<UpgradeRequestContext> for &UpgradeAction {
+    async fn to_response(self, request: UpgradeRequestContext) -> Result<Response<PolyBody>> {
+        let UpgradeRequestContext { request, route_match, source_address } = request;
+        let hash_state = HashState::new(&[], &request, source_address);
+        let maybe_channel = clusters_manager::get_http_connection(&self.cluster_specifier, Some(hash_state));
+
+        match maybe_channel {
+            Ok(svc_channel) => {
+                let version = request.version();
+                let mut request: Request<PolyBody> = {
+                    let (mut parts, body) = request.into_parts();
+                    let path_and_query_replacement = if let Some(rewrite) = &self.rewrite {
+                        rewrite.apply(parts.uri.path_and_query(), &route_match).context("invalid path after rewrite")?
+                    } else {
+                        None
+                    };
+                    if path_and_query_replacement.is_some() {
+                        parts.uri = {
+                            let UriParts { scheme, authority, path_and_query: _, .. } = parts.uri.into_parts();
+                            let mut new_parts = UriParts::default();
+                            new_parts.scheme = scheme;
+                            new_parts.authority = authority;
+                            new_parts.path_and_query = path_and_query_replacement;
+                            Uri::from_parts(new_parts).context("failed to replace request path_and_query")?
+                        }
+                    }
+                    Request::from_parts(parts, body.into())
+                };
+                match (self.upgrade_type.clone(), version) {
+                    (UpgradeActionType::Websocket, Version::HTTP_11) => {
+                        let request_upgrade = hyper::upgrade::on(&mut request);
+                        match svc_channel.to_response(RequestWithContext::new(request)).await {
+                            Ok(mut upstream_response)
+                                if upstream_response.status() == StatusCode::SWITCHING_PROTOCOLS =>
+                            {
+                                let response_upgrade = hyper::upgrade::on(&mut upstream_response);
+                                tokio::spawn(async move {
+                                    match (request_upgrade.await, response_upgrade.await) {
+                                        (Ok(request_upgraded), Ok(response_upgraded)) => {
+                                            let _ = copy_bidirectional(
+                                                &mut TokioIo::new(request_upgraded),
+                                                &mut TokioIo::new(response_upgraded),
+                                            )
+                                            .await
+                                            .map_err(|err| {
+                                                error!(
+                                                    "HttpConnectionManager bidi copy failed for websocket {:?}",
+                                                    err
+                                                );
+                                                err
+                                            });
+                                        },
+                                        (req_state, resp_state) => {
+                                            error!("HttpConnectionManager problem occurred during connection upgrade {:?},{:?}", req_state, resp_state);
+                                        },
+                                    }
+                                });
+                                Ok(upstream_response)
+                            },
+                            Ok(response) => {
+                                error!("HttpConnectionManager upstream did not accept websocket upgrade, returned status code {:?}", response.status());
+                                Ok(SyntheticHttpResponse::not_allowed().into_response(version))
+                            },
+                            Err(err) => {
+                                error!(
+                                    "HttpConnectionManager failed attempting to establish upstream websocket {:?}",
+                                    err
+                                );
+                                Ok(SyntheticHttpResponse::bad_gateway().into_response(version))
+                            },
+                        }
+                    },
+                    (UpgradeActionType::Websocket, _) => {
+                        Ok(SyntheticHttpResponse::bad_request().into_response(version))
+                    },
+                    (UpgradeActionType::Connect { allow_post: _ }, _) => {
+                        Ok(SyntheticHttpResponse::upgrade_required().into_response(version))
+                    },
+                }
+            },
+
+            Err(err) => {
+                debug!("Failed to get an HTTP connection for upgrade: {:?}", err);
+                Ok(SyntheticHttpResponse::internal_error().into_response(request.version()))
+            },
+        }
+    }
+}
diff --git a/orion-lib/src/listeners/listener.rs b/orion-lib/src/listeners/listener.rs
index 25e4406c..83752e16 100644
--- a/orion-lib/src/listeners/listener.rs
+++ b/orion-lib/src/listeners/listener.rs
@@ -378,7 +378,7 @@ impl Listener {
                         if let Some(route_id) = route_id {
                             if route_id == id {
                                 debug!("{listener_name} Route updated {id} {route:?}");
-                                http_manager.update_route(Arc::new(route.clone()));
+                                http_manager.update_route(route.clone());
                             }
                         } else {
                             debug!("{listener_name} Got route update but id doesn't match {route_id:?} {id}");
diff --git a/orion-lib/src/listeners/synthetic_http_response.rs b/orion-lib/src/listeners/synthetic_http_response.rs
index 872bafc7..619b437f 100644
--- a/orion-lib/src/listeners/synthetic_http_response.rs
+++ b/orion-lib/src/listeners/synthetic_http_response.rs
@@ -79,6 +79,34 @@ impl SyntheticHttpResponse {
         Self { http_status: StatusCode::NOT_FOUND, body: Bytes::default(), close_connection: false }
     }
 
+    #[allow(dead_code)]
+    pub fn upgrade_required() -> Self {
+        Self { http_status: StatusCode::UPGRADE_REQUIRED, body: Bytes::default(), close_connection: true }
+    }
+
+    #[allow(dead_code)]
+    pub fn bad_request() -> Self {
+        Self { http_status: StatusCode::BAD_REQUEST, body: Bytes::default(), close_connection: true }
+    }
+
+    pub fn not_allowed() -> Self {
+        Self { http_status: StatusCode::METHOD_NOT_ALLOWED, body: Bytes::default(), close_connection: true }
+    }
+
+    #[allow(dead_code)]
+    pub fn upgrade_required() -> Self {
+        Self { http_status: StatusCode::UPGRADE_REQUIRED, body: Bytes::default(), close_connection: true }
+    }
+
+    #[allow(dead_code)]
+    pub fn bad_request() -> Self {
+        Self { http_status: StatusCode::BAD_REQUEST, body: Bytes::default(), close_connection: true }
+    }
+
+    pub fn not_allowed() -> Self {
+        Self { http_status: StatusCode::METHOD_NOT_ALLOWED, body: Bytes::default(), close_connection: true }
+    }
+
     // TODO: Implement custom error responses - used for flexible error handling
     pub fn custom_error(http_status: StatusCode) -> Self {
         Self { http_status, body: Bytes::default(), close_connection: false }
diff --git a/orion-proxy/conf/envoy-bootstrap-dyn.yaml b/orion-proxy/conf/envoy-bootstrap-dyn.yaml
new file mode 100644
index 00000000..89c22c31
--- /dev/null
+++ b/orion-proxy/conf/envoy-bootstrap-dyn.yaml
@@ -0,0 +1,137 @@
+node:
+  id: "test-id"
+dynamic_resources:
+  ads_config:
+    # api_type: GRPC
+    # transport_api_version: V3
+    grpc_services:
+      - envoy_grpc:
+          cluster_name: xds_cluster
+static_resources:
+  listeners:
+    - name: listener_http
+      address:
+        socket_address: { address: 127.0.0.1, port_value: 8000 }
+      filter_chains:
+        - name: filter_chain_http1
+          filters:
+            - name: http_gateway
+              typed_config:
+                "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
+                httpFilters:
+                  - name: envoy.filters.http.router
+                    typedConfig:
+                      "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router
+                      start_child_span: false
+                codec_type: HTTP1                
+                rds:
+                  config_source:
+                    ads: {}                      
+                  route_config_name: "basic_http_route1"                
+
+    - name: listener_http2
+      address:
+        socket_address: { address: 127.0.0.1, port_value: 8002 }
+      filter_chains:
+        - name: filter_chain_http2          
+          filters:
+            - name: http_gateway
+              typed_config:
+                "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
+                httpFilters:
+                  - name: envoy.filters.http.router
+                    typedConfig:
+                      "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router
+                      start_child_span: false
+                codec_type: HTTP1
+                upgrade_configs:
+                  - upgrade_type: websocket
+                route_config:
+                  name: basic_http_route2
+                  virtual_hosts:
+                    - name: backend
+                      domains: ["*"]
+                      routes:
+                        - match:
+                            prefix: "/"
+                            headers:
+                              - name: ":method"
+                                exactMatch: "GET"
+                          route:
+                            cluster: cluster_http
+                        - match:
+                            prefix: "/"
+                            headers:
+                              - name: ":method"
+                                exactMatch: "POST"
+                          route:
+                            cluster: cluster_http                            
+
+
+                            
+    - name: listener_tcp
+      address:
+        socket_address: { address: 127.0.0.1, port_value: 8001 }
+      filter_chains:
+        - name: filter_chain_tcp          
+          filters:
+            - name: tcp_proxy_filter
+              typed_config:
+                "@type": type.googleapis.com/envoy.extensions.filters.network.tcp_proxy.v3.TcpProxy
+                stat_prefix: ingress_tcp
+                cluster: cluster_http
+
+  clusters:
+    - name: xds_cluster
+      connect_timeout: 0.25s
+      type: STATIC
+      lb_policy: ROUND_ROBIN
+      load_assignment:
+        endpoints:
+          - lb_endpoints:
+              - endpoint:
+                  address:
+                    socket_address:
+                      address: 127.0.0.1
+                      port_value: 18000
+    - name: cluster_http
+      connect_timeout: 0.25s
+      type: STATIC
+      lb_policy: ROUND_ROBIN
+        
+      typed_extension_protocol_options:
+        envoy.extensions.upstreams.http.v3.HttpProtocolOptions:
+          "@type": type.googleapis.com/envoy.extensions.upstreams.http.v3.HttpProtocolOptions
+          common_http_protocol_options:
+            idle_timeout: 1s        
+
+      load_assignment:
+        endpoints:            
+          - priority: 0
+            lb_endpoints:
+              - endpoint:                  
+                  address:
+                    socket_address:
+                      address: 127.0.0.1
+                      port_value: 4001
+                load_balancing_weight: 1
+              - endpoint:                
+                  address:
+                    socket_address:
+                      address: 127.0.0.1
+                      port_value: 4002
+                load_balancing_weight: 1                      
+          - priority: 0
+            lb_endpoints:
+              - endpoint:                
+                  address:
+                    socket_address:
+                      address: 127.0.0.1
+                      port_value: 4005
+                load_balancing_weight: 1                      
+              - endpoint:                
+                  address:
+                    socket_address:
+                      address: 127.0.0.1
+                      port_value: 4006
+                load_balancing_weight: 1

From 68d904b419559234db7b1a86b9679d64f4c3fc40 Mon Sep 17 00:00:00 2001
From: Dawid Nowak <dawid.nowak@huawei.com>
Date: Thu, 29 May 2025 21:27:59 +0100
Subject: [PATCH 58/64] Changes, formatting and cleaning some

Signed-off-by: Dawid Nowak <dawid.nowak@huawei.com>
---
 Cargo.lock                                    | 10 ----
 orion-configuration/src/config/bootstrap.rs   |  5 +-
 orion-configuration/src/config/cluster.rs     | 12 ++--
 .../src/config/cluster/health_check.rs        |  4 +-
 .../config/cluster/http_protocol_options.rs   |  2 +-
 orion-configuration/src/config/core.rs        |  4 +-
 .../http_connection_manager.rs                |  8 +--
 .../http_connection_manager/route.rs          | 13 ++--
 orion-format/benches/benchmark.rs             |  5 +-
 orion-format/src/lib.rs                       |  2 +-
 orion-format/src/types.rs                     | 60 +++++++++----------
 .../clusters/balancers/default_balancer.rs    |  3 +-
 orion-lib/src/clusters/cluster.rs             |  2 +-
 .../src/listeners/synthetic_http_response.rs  | 14 -----
 orion-lib/src/secrets/secrets_manager.rs      |  2 +-
 .../tls_configurator_builder.rs               |  2 +-
 orion-lib/src/transport/http_channel.rs       |  2 +-
 orion-lib/src/transport/resolver.rs           |  2 +-
 orion-proxy/src/core_affinity.rs              | 12 ++--
 orion-xds/examples/client.rs                  |  5 +-
 orion-xds/examples/server.rs                  | 13 ++--
 orion-xds/examples/server_routes_and_loads.rs | 13 ++--
 orion-xds/examples/server_secret_rotation.rs  |  9 +--
 orion-xds/src/xds/resources/mod.rs            |  4 +-
 24 files changed, 87 insertions(+), 121 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c0ce2844..f5bdcc0b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3558,16 +3558,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
-[[package]]
-name = "windows"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
-dependencies = [
- "windows-core",
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-core"
 version = "0.61.2"
diff --git a/orion-configuration/src/config/bootstrap.rs b/orion-configuration/src/config/bootstrap.rs
index 90db7925..ccee967b 100644
--- a/orion-configuration/src/config/bootstrap.rs
+++ b/orion-configuration/src/config/bootstrap.rs
@@ -126,7 +126,7 @@ mod envoy_conversions {
                 application_log_config,
                 grpc_async_client_manager_config,
                 stats_flush,
-                memory_allocator_manager: _,
+                memory_allocator_manager,
             } = envoy;
             unsupported_field!(
                 // node,
@@ -166,7 +166,8 @@ mod envoy_conversions {
                 listener_manager,
                 application_log_config,
                 grpc_async_client_manager_config,
-                stats_flush
+                stats_flush,
+                memory_allocator_manager
             )?;
             let static_resources = convert_opt!(static_resources)?;
             let dynamic_resources =
diff --git a/orion-configuration/src/config/cluster.rs b/orion-configuration/src/config/cluster.rs
index c850f093..19bb3598 100644
--- a/orion-configuration/src/config/cluster.rs
+++ b/orion-configuration/src/config/cluster.rs
@@ -301,8 +301,8 @@ mod envoy_conversions {
                 connection_pool_per_downstream_connection,
                 cluster_discovery_type,
                 lb_config,
-                dns_jitter: _,
-                lrs_report_endpoint_metrics: _,
+                dns_jitter,
+                lrs_report_endpoint_metrics,
             } = envoy;
             let name = required!(name)?;
             (|| -> Result<Self, GenericError> {
@@ -350,9 +350,11 @@ mod envoy_conversions {
                     upstream_config,
                     track_cluster_stats,
                     preconnect_policy,
-                    connection_pool_per_downstream_connection
-                    // cluster_discovery_type,                                                              
-                    // lb_config
+                    connection_pool_per_downstream_connection,
+                    dns_jitter, // cluster_discovery_type,
+                    lrs_report_endpoint_metrics
+                                                              // lb_config
+
                 )?;
 
                 if let Some(lb_config_type) = &lb_config {
diff --git a/orion-configuration/src/config/cluster/health_check.rs b/orion-configuration/src/config/cluster/health_check.rs
index 5e27cd34..44a919c0 100644
--- a/orion-configuration/src/config/cluster/health_check.rs
+++ b/orion-configuration/src/config/cluster/health_check.rs
@@ -331,8 +331,8 @@ mod envoy_conversions {
                 event_service,
                 always_log_health_check_failures,
                 tls_options,
-                transport_socket_match_criteria, // health_checker
-                always_log_health_check_success
+                transport_socket_match_criteria,
+                always_log_health_check_success // health_checker
             )?;
             let timeout = duration_from_envoy(required!(timeout)?).map_err(|e| {
                 GenericError::from_msg_with_cause("failed to convert {timeout} to std::time::Duration", e)
diff --git a/orion-configuration/src/config/cluster/http_protocol_options.rs b/orion-configuration/src/config/cluster/http_protocol_options.rs
index d2d21451..df551e96 100644
--- a/orion-configuration/src/config/cluster/http_protocol_options.rs
+++ b/orion-configuration/src/config/cluster/http_protocol_options.rs
@@ -101,7 +101,7 @@ pub struct Http2ProtocolOptions {
 
 impl Http2ProtocolOptions {
     pub fn max_concurrent_streams(&self) -> Option<usize> {
-        self.max_concurrent_streams.map(usize::from)
+        self.max_concurrent_streams
     }
     pub fn initial_stream_window_size(&self) -> Option<u32> {
         self.initial_stream_window_size.map(u32::from)
diff --git a/orion-configuration/src/config/core.rs b/orion-configuration/src/config/core.rs
index 27b17e5d..688880d9 100644
--- a/orion-configuration/src/config/core.rs
+++ b/orion-configuration/src/config/core.rs
@@ -365,9 +365,7 @@ mod envoy_conversions {
                 EnvoyStringMatcherPattern::Prefix(s) => Ok(Self::Prefix(s.into())),
                 EnvoyStringMatcherPattern::Suffix(s) => Ok(Self::Suffix(s.into())),
                 EnvoyStringMatcherPattern::SafeRegex(r) => Ok(Self::Regex(regex_from_envoy(r)?)),
-                EnvoyStringMatcherPattern::Custom(_) => {
-                    Err(GenericError::UnsupportedField("EnvoyStringMatcherPattern::Custom"))
-                },
+                EnvoyStringMatcherPattern::Custom(_) => Err(GenericError::from_msg("Custom is not supported")),
             }
         }
     }
diff --git a/orion-configuration/src/config/network_filters/http_connection_manager.rs b/orion-configuration/src/config/network_filters/http_connection_manager.rs
index 117da12c..94fafbdc 100644
--- a/orion-configuration/src/config/network_filters/http_connection_manager.rs
+++ b/orion-configuration/src/config/network_filters/http_connection_manager.rs
@@ -678,7 +678,7 @@ mod tests {
                 hash_policy: vec![],
             }),
         };
-        let routes_a = route_a.unfold_upgrades(&vec![]);
+        let routes_a = route_a.unfold_upgrades(&[]);
         assert_eq!(routes_a.len(), 3);
         match routes_a.as_slice() {
             [ws_upgrade_route, reject_connect_route, vanilla_http_route] => {
@@ -700,7 +700,7 @@ mod tests {
                     "expected to retain original http route when derving upgrade route matchers"
                 );
             },
-            _ => panic!("expected three dervied routes"),
+            _ => unimplemented!("expected three dervied routes"),
         }
         let route_b = Route {
             route_match: RouteMatch {
@@ -721,7 +721,7 @@ mod tests {
             }),
             ..route_a.clone()
         };
-        let routes_b = route_b.unfold_upgrades(&vec![UpgradeType::Connect]);
+        let routes_b = route_b.unfold_upgrades(&[UpgradeType::Connect]);
         assert_eq!(routes_b.len(), 3);
         match routes_b.as_slice() {
             [ws_reject_route, connect_matcher, vanilla_http_route] => {
@@ -739,7 +739,7 @@ mod tests {
                     "expected to retain original http route when derving the connec upgrade matcher"
                 );
             },
-            _ => panic!("expected three dervied routes"),
+            _ => unimplemented!("expected three dervied routes"),
         }
     }
 }
diff --git a/orion-configuration/src/config/network_filters/http_connection_manager/route.rs b/orion-configuration/src/config/network_filters/http_connection_manager/route.rs
index 07a77215..a86b29f2 100644
--- a/orion-configuration/src/config/network_filters/http_connection_manager/route.rs
+++ b/orion-configuration/src/config/network_filters/http_connection_manager/route.rs
@@ -562,7 +562,7 @@ mod envoy_conversions {
         },
         r#type::matcher::v3::RegexMatchAndSubstitute as EnvoyRegexMatchAndSubstitute,
     };
-    use ng2_data_plane_api::envoy_data_plane_api::google::protobuf::BoolValue;
+    use orion_data_plane_api::envoy_data_plane_api::google::protobuf::BoolValue;
     use std::{num::NonZeroU16, str::FromStr};
 
     impl TryFrom<EnvoyHashPolicy> for HashPolicy {
@@ -783,11 +783,12 @@ mod envoy_conversions {
                 // cluster_specifier,
                 host_rewrite_specifier
             )?;
-            let cluster_not_found_response_code = cluster_not_found_response_code
-                .is_used()
-                .then(|| http_status_from(cluster_not_found_response_code))
-                .unwrap_or(Ok(super::DEFAULT_CLUSTER_NOT_FOUND_STATUSCODE))
-                .with_node("cluster_not_found_response_code")?;
+            let cluster_not_found_response_code = if cluster_not_found_response_code.is_used() {
+                http_status_from(cluster_not_found_response_code)
+            } else {
+                Ok(super::DEFAULT_CLUSTER_NOT_FOUND_STATUSCODE)
+            }
+            .with_node("cluster_not_found_response_code")?;
             let timeout = timeout.map(duration_from_envoy).unwrap_or(Ok(DEFAULT_TIMEOUT)).with_node("timeout")?;
             // in envoy, the default value for the timeout (if not set) is 15s, but setting the timeout disables it.
             // in order to better match the rest of the code/rust, we map disabled to None and the default to Some(15s)
diff --git a/orion-format/benches/benchmark.rs b/orion-format/benches/benchmark.rs
index 908aac0f..f41662aa 100644
--- a/orion-format/benches/benchmark.rs
+++ b/orion-format/benches/benchmark.rs
@@ -27,7 +27,6 @@ where
     fmt.with_context(end);
 }
 
-#[inline(always)]
 fn header_lookup<'a>(name: &'a str, m: &'a HeaderMap, default_header: &'a HeaderValue) -> &'a HeaderValue {
     m.get(name).unwrap_or(default_header)
 }
@@ -45,7 +44,7 @@ impl<T> UnwrapClippyWorkaround for Option<T> {
     fn stealth_unwrap(self) -> Self::Target {
         match self {
             Some(value) => value,
-            None => panic!("Called stealth_unwrap on None"),
+            None => unimplemented!("Called stealth_unwrap on None"),
         }
     }
 }
@@ -59,7 +58,7 @@ where
     fn stealth_unwrap(self) -> Self::Target {
         match self {
             Ok(value) => value,
-            Err(e) => panic!("Called stealth_unwrap on Err({e})"),
+            Err(e) => unimplemented!("Called stealth_unwrap on Err({e})"),
         }
     }
 }
diff --git a/orion-format/src/lib.rs b/orion-format/src/lib.rs
index 86e1da31..445469b5 100644
--- a/orion-format/src/lib.rs
+++ b/orion-format/src/lib.rs
@@ -70,7 +70,7 @@ impl Default for LogFormatter {
         if let Ok(log) = LogFormatter::try_new(DEFAULT_ENVOY_FORMAT) {
             log
         } else {
-            panic!("Failed to create default LogFormatter")
+            unimplemented!("Failed to create default LogFormatter")
         }
     }
 }
diff --git a/orion-format/src/types.rs b/orion-format/src/types.rs
index 4d59a039..d588f5e4 100644
--- a/orion-format/src/types.rs
+++ b/orion-format/src/types.rs
@@ -4,36 +4,36 @@ use smol_str::{SmolStr, SmolStrBuilder, ToSmolStr};
 bitflags! {
     #[derive(PartialEq, Clone, Debug)]
     pub struct ResponseFlags: u32 {
-        const NO_HEALTHY_UPSTREAM                   = 0b000000000000000000000000000001;
-        const UPSTREAM_CONNECTION_FAILURE           = 0b000000000000000000000000000010;
-        const UPSTREAM_OVERFLOW                     = 0b000000000000000000000000000100;
-        const NO_ROUTE_FOUND                        = 0b000000000000000000000000001000;
-        const UPSTREAM_RETRY_LIMIT_EXCEEDED         = 0b000000000000000000000000010000;
-        const NO_CLUSTER_FOUND                      = 0b000000000000000000000000100000;
-        const DURATION_TIMEOUT                      = 0b000000000000000000000001000000;
-        const DOWNSTREAM_CONNECTION_TERMINATION     = 0b000000000000000000000010000000;
-        const FAILED_LOCAL_HEALTH_CHECK             = 0b000000000000000000000100000000;
-        const UPSTREAM_REQUEST_TIMEOUT              = 0b000000000000000000001000000000;
-        const LOCAL_RESET                           = 0b000000000000000000010000000000;
-        const UPSTREAM_REMOTE_RESET                 = 0b000000000000000000100000000000;
-        const UPSTREAM_CONNECTION_TERMINATION       = 0b000000000000000001000000000000;
-        const DELAY_INJECTED                        = 0b000000000000000010000000000000;
-        const FAULT_INJECTED                        = 0b000000000000000100000000000000;
-        const RATE_LIMITED                          = 0b000000000000001000000000000000;
-        const UNAUTHORIZED_EXTERNAL_SERVICE         = 0b000000000000010000000000000000;
-        const RATE_LIMIT_SERVICE_ERROR              = 0b000000000000100000000000000000;
-        const INVALID_ENVOY_REQUEST_HEADERS         = 0b000000000001000000000000000000;
-        const STREAM_IDLE_TIMEOUT                   = 0b000000000010000000000000000000;
-        const DOWNSTREAM_PROTOCOL_ERROR             = 0b000000000100000000000000000000;
-        const UPSTREAM_PROTOCOL_ERROR               = 0b000000001000000000000000000000;
-        const UPSTREAM_MAX_STREAM_DURATION_REACHED  = 0b000000010000000000000000000000;
-        const RESPONSE_FROM_CACHE_FILTER            = 0b000000100000000000000000000000;
-        const NO_FILTER_CONFIG_FOUND                = 0b000001000000000000000000000000;
-        const OVERLOAD_MANAGER_TERMINATED           = 0b000010000000000000000000000000;
-        const DNS_RESOLUTION_FAILED                 = 0b000100000000000000000000000000;
-        const DROP_OVERLOAD                         = 0b001000000000000000000000000000;
-        const DOWNSTREAM_REMOTE_RESET               = 0b010000000000000000000000000000;
-        const UNCONDITIONAL_DROP_OVERLOAD           = 0b100000000000000000000000000000;
+        const NO_HEALTHY_UPSTREAM                   = 0b00_0000_0000_0000_0000_0000_0000_0001;
+        const UPSTREAM_CONNECTION_FAILURE           = 0b00_0000_0000_0000_0000_0000_0000_0010;
+        const UPSTREAM_OVERFLOW                     = 0b00_0000_0000_0000_0000_0000_0000_0100;
+        const NO_ROUTE_FOUND                        = 0b00_0000_0000_0000_0000_0000_0000_1000;
+        const UPSTREAM_RETRY_LIMIT_EXCEEDED         = 0b00_0000_0000_0000_0000_0000_0001_0000;
+        const NO_CLUSTER_FOUND                      = 0b00_0000_0000_0000_0000_0000_0010_0000;
+        const DURATION_TIMEOUT                      = 0b00_0000_0000_0000_0000_0000_0100_0000;
+        const DOWNSTREAM_CONNECTION_TERMINATION     = 0b00_0000_0000_0000_0000_0000_1000_0000;
+        const FAILED_LOCAL_HEALTH_CHECK             = 0b00_0000_0000_0000_0000_0001_0000_0000;
+        const UPSTREAM_REQUEST_TIMEOUT              = 0b00_0000_0000_0000_0000_0010_0000_0000;
+        const LOCAL_RESET                           = 0b00_0000_0000_0000_0000_0100_0000_0000;
+        const UPSTREAM_REMOTE_RESET                 = 0b00_0000_0000_0000_0000_1000_0000_0000;
+        const UPSTREAM_CONNECTION_TERMINATION       = 0b00_0000_0000_0000_0001_0000_0000_0000;
+        const DELAY_INJECTED                        = 0b00_0000_0000_0000_0010_0000_0000_0000;
+        const FAULT_INJECTED                        = 0b00_0000_0000_0000_0100_0000_0000_0000;
+        const RATE_LIMITED                          = 0b00_0000_0000_0000_1000_0000_0000_0000;
+        const UNAUTHORIZED_EXTERNAL_SERVICE         = 0b00_0000_0000_0001_0000_0000_0000_0000;
+        const RATE_LIMIT_SERVICE_ERROR              = 0b00_0000_0000_0010_0000_0000_0000_0000;
+        const INVALID_ENVOY_REQUEST_HEADERS         = 0b00_0000_0000_0100_0000_0000_0000_0000;
+        const STREAM_IDLE_TIMEOUT                   = 0b00_0000_0000_1000_0000_0000_0000_0000;
+        const DOWNSTREAM_PROTOCOL_ERROR             = 0b00_0000_0001_0000_0000_0000_0000_0000;
+        const UPSTREAM_PROTOCOL_ERROR               = 0b00_0000_0010_0000_0000_0000_0000_0000;
+        const UPSTREAM_MAX_STREAM_DURATION_REACHED  = 0b00_0000_0100_0000_0000_0000_0000_0000;
+        const RESPONSE_FROM_CACHE_FILTER            = 0b00_0000_1000_0000_0000_0000_0000_0000;
+        const NO_FILTER_CONFIG_FOUND                = 0b00_0001_0000_0000_0000_0000_0000_0000;
+        const OVERLOAD_MANAGER_TERMINATED           = 0b00_0010_0000_0000_0000_0000_0000_0000;
+        const DNS_RESOLUTION_FAILED                 = 0b00_0100_0000_0000_0000_0000_0000_0000;
+        const DROP_OVERLOAD                         = 0b00_1000_0000_0000_0000_0000_0000_0000;
+        const DOWNSTREAM_REMOTE_RESET               = 0b01_0000_0000_0000_0000_0000_0000_0000;
+        const UNCONDITIONAL_DROP_OVERLOAD           = 0b10_0000_0000_0000_0000_0000_0000_0000;
     }
 }
 
diff --git a/orion-lib/src/clusters/balancers/default_balancer.rs b/orion-lib/src/clusters/balancers/default_balancer.rs
index 1fa3a1d3..4b5af295 100644
--- a/orion-lib/src/clusters/balancers/default_balancer.rs
+++ b/orion-lib/src/clusters/balancers/default_balancer.rs
@@ -153,6 +153,7 @@ where
 #[cfg(test)]
 mod test {
     use compact_str::ToCompactString;
+    use orion_configuration::config::cluster::HttpProtocolOptions;
     use std::sync::Arc;
 
     use rustls::ClientConfig;
@@ -188,7 +189,7 @@ mod test {
                 healthy_endpoints: healthy,
                 total_endpoints: u32::try_from(len).expect("Too many endpoints"),
                 tls_configurator: Option::<TlsConfigurator<ClientConfig, WantsToBuildClient>>::None,
-                http_protocol_options: Default::default(),
+                http_protocol_options: HttpProtocolOptions::default(),
                 connection_timeout: None,
             });
         }
diff --git a/orion-lib/src/clusters/cluster.rs b/orion-lib/src/clusters/cluster.rs
index d88c17a1..42cee2a8 100644
--- a/orion-lib/src/clusters/cluster.rs
+++ b/orion-lib/src/clusters/cluster.rs
@@ -240,7 +240,7 @@ impl ClusterOps for DynamicCluster {
                 load_assignment.tls_configurator = Some(tls_configurator.clone());
                 let load_assignment = load_assignment.rebuild()?;
                 self.load_assignment = Some(load_assignment);
-            };
+            }
             self.tls_configurator = Some(tls_configurator);
         }
         Ok(())
diff --git a/orion-lib/src/listeners/synthetic_http_response.rs b/orion-lib/src/listeners/synthetic_http_response.rs
index 619b437f..dc797444 100644
--- a/orion-lib/src/listeners/synthetic_http_response.rs
+++ b/orion-lib/src/listeners/synthetic_http_response.rs
@@ -93,20 +93,6 @@ impl SyntheticHttpResponse {
         Self { http_status: StatusCode::METHOD_NOT_ALLOWED, body: Bytes::default(), close_connection: true }
     }
 
-    #[allow(dead_code)]
-    pub fn upgrade_required() -> Self {
-        Self { http_status: StatusCode::UPGRADE_REQUIRED, body: Bytes::default(), close_connection: true }
-    }
-
-    #[allow(dead_code)]
-    pub fn bad_request() -> Self {
-        Self { http_status: StatusCode::BAD_REQUEST, body: Bytes::default(), close_connection: true }
-    }
-
-    pub fn not_allowed() -> Self {
-        Self { http_status: StatusCode::METHOD_NOT_ALLOWED, body: Bytes::default(), close_connection: true }
-    }
-
     // TODO: Implement custom error responses - used for flexible error handling
     pub fn custom_error(http_status: StatusCode) -> Self {
         Self { http_status, body: Bytes::default(), close_connection: false }
diff --git a/orion-lib/src/secrets/secrets_manager.rs b/orion-lib/src/secrets/secrets_manager.rs
index 4cee6449..376737fb 100644
--- a/orion-lib/src/secrets/secrets_manager.rs
+++ b/orion-lib/src/secrets/secrets_manager.rs
@@ -101,7 +101,7 @@ impl TryFrom<&TlsCertificate> for CertificateSecret {
             .map(|f| f.map_err(|e| format!("Can't parse certificate {e:?}").into()))
             .collect::<Result<Vec<_>>>()?;
 
-        let certificates: Vec<_> = certificates.into_iter().map(CertificateDer::from).collect();
+        let certificates: Vec<_> = certificates.into_iter().collect();
         let Some(cert) = certificates.first() else {
             return Err("No certificates have been configured".into());
         };
diff --git a/orion-lib/src/secrets/tls_configurator/tls_configurator_builder.rs b/orion-lib/src/secrets/tls_configurator/tls_configurator_builder.rs
index 8cb6bfc6..48ef77de 100644
--- a/orion-lib/src/secrets/tls_configurator/tls_configurator_builder.rs
+++ b/orion-lib/src/secrets/tls_configurator/tls_configurator_builder.rs
@@ -271,7 +271,7 @@ impl TlsContextBuilder<WantsToBuildServer> {
             // If only a single certificate exists, do not install SNI resolver, just accept all
             // connections using the provided certificate
             return Ok(builder.with_single_cert(certs.to_vec(), key.clone_key())?);
-        };
+        }
 
         let mut resolver = RelaxedResolvesServerCertUsingSni::new();
         let errors = self
diff --git a/orion-lib/src/transport/http_channel.rs b/orion-lib/src/transport/http_channel.rs
index 53a0506a..bfbe5a59 100644
--- a/orion-lib/src/transport/http_channel.rs
+++ b/orion-lib/src/transport/http_channel.rs
@@ -173,7 +173,7 @@ impl HttpChannelBuilder {
                 client_builder.http2_keep_alive_interval(settings.keep_alive_interval);
                 if let Some(timeout) = settings.keep_alive_timeout {
                     client_builder.http2_keep_alive_timeout(timeout);
-                };
+                }
                 client_builder.http2_keep_alive_while_idle(true);
             }
             client_builder.http2_initial_connection_window_size(http2_options.initial_connection_window_size());
diff --git a/orion-lib/src/transport/resolver.rs b/orion-lib/src/transport/resolver.rs
index e355ed45..c5d24419 100644
--- a/orion-lib/src/transport/resolver.rs
+++ b/orion-lib/src/transport/resolver.rs
@@ -38,7 +38,7 @@ pub async fn resolve(host: &str, port: u16) -> io::Result<SocketAddr> {
             {
                 match TokioAsyncResolver::from_system_conf(TokioConnectionProvider::default()) {
                     Ok(resolver) => resolver,
-                    Err(err) => panic!("Could not initialize the DNS resolver: {err}"),
+                    Err(err) => unimplemented!("Could not initialize the DNS resolver: {err}"),
                 }
             }
             #[cfg(not(any(unix, windows)))]
diff --git a/orion-proxy/src/core_affinity.rs b/orion-proxy/src/core_affinity.rs
index b09a4039..5cd5af50 100644
--- a/orion-proxy/src/core_affinity.rs
+++ b/orion-proxy/src/core_affinity.rs
@@ -211,7 +211,7 @@ mod tests {
     #[test]
     fn test_group_by_numa_single() {
         let cores = core_ids![0, 1, 2, 3];
-        let cpuinfo = r###"processor       : 0
+        let cpuinfo = r"processor       : 0
 vendor_id       : GenuineIntel
 cpu family      : 6
 model           : 140
@@ -317,14 +317,14 @@ bogomips        : 5606.42
 clflush size    : 64
 cache_alignment : 64
 address sizes   : 39 bits physical, 48 bits virtual
-power management:"###;
+power management:";
         assert_eq!(group_by_numa(cores, cpuinfo).unwrap(), vec![core_ids![0, 1, 2, 3]]);
     }
 
     #[test]
     fn test_group_by_numa_err() {
         let cores = core_ids![4, 5, 6, 7];
-        let cpuinfo = r###"processor       : 0
+        let cpuinfo = r"processor       : 0
 vendor_id       : GenuineIntel
 cpu family      : 6
 model           : 140
@@ -430,14 +430,14 @@ bogomips        : 5606.42
 clflush size    : 64
 cache_alignment : 64
 address sizes   : 39 bits physical, 48 bits virtual
-power management:"###;
+power management:";
         assert!(group_by_numa(cores, cpuinfo).is_err());
     }
 
     #[test]
     fn test_group_by_numa_dual_nodes() {
         let cores = core_ids![0, 1, 2, 3];
-        let cpuinfo = r###"processor       : 0
+        let cpuinfo = r"processor       : 0
 vendor_id       : GenuineIntel
 cpu family      : 6
 model           : 140
@@ -543,7 +543,7 @@ bogomips        : 5606.42
 clflush size    : 64
 cache_alignment : 64
 address sizes   : 39 bits physical, 48 bits virtual
-power management:"###;
+power management:";
         assert_eq!(group_by_numa(cores, cpuinfo).unwrap(), vec![core_ids![0, 2], core_ids![1, 3]]);
     }
 
diff --git a/orion-xds/examples/client.rs b/orion-xds/examples/client.rs
index f149915e..d4480939 100644
--- a/orion-xds/examples/client.rs
+++ b/orion-xds/examples/client.rs
@@ -13,10 +13,7 @@ use tracing_subscriber::EnvFilter;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::try_from_default_env()
-                .unwrap_or_else(|_| "info,orion_xds=debug".into()),
-        )
+        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info,orion_xds=debug".into()))
         .init();
 
     let (mut worker, mut client, _subscription_manager) =
diff --git a/orion-xds/examples/server.rs b/orion-xds/examples/server.rs
index de549652..08843b0d 100644
--- a/orion-xds/examples/server.rs
+++ b/orion-xds/examples/server.rs
@@ -8,10 +8,7 @@ use tracing_subscriber::EnvFilter;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::try_from_default_env()
-                .unwrap_or_else(|_| "info,orion_xds=debug".into()),
-        )
+        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info,orion_xds=debug".into()))
         .init();
 
     let (delta_resource_tx, delta_resources_rx) = tokio::sync::mpsc::channel(100);
@@ -42,7 +39,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
             if delta_resource_tx.send(ServerAction::Add(cluster_resource.clone())).await.is_err() {
                 break;
-            };
+            }
             tokio::time::sleep(Duration::from_secs(5)).await;
             let listener = resources::create_listener(
                 &listener_id,
@@ -55,13 +52,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             info!("Adding listener {listener_resource:?}");
             if delta_resource_tx.send(ServerAction::Add(listener_resource)).await.is_err() {
                 break;
-            };
+            }
             tokio::time::sleep(Duration::from_secs(15)).await;
 
             info!("Removing cluster {cluster_id}");
             if delta_resource_tx.send(ServerAction::Remove(cluster_resource)).await.is_err() {
                 break;
-            };
+            }
             tokio::time::sleep(Duration::from_secs(5)).await;
             let listener = resources::create_listener(
                 &listener_id,
@@ -74,7 +71,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             info!("Removing listener {listener_resource:?}");
             if delta_resource_tx.send(ServerAction::Remove(listener_resource)).await.is_err() {
                 break;
-            };
+            }
         }
     });
 
diff --git a/orion-xds/examples/server_routes_and_loads.rs b/orion-xds/examples/server_routes_and_loads.rs
index 8497351f..aec54131 100644
--- a/orion-xds/examples/server_routes_and_loads.rs
+++ b/orion-xds/examples/server_routes_and_loads.rs
@@ -11,10 +11,7 @@ use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilte
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::try_from_default_env()
-                .unwrap_or_else(|_| "info,orion_xds=debug".into()),
-        )
+        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info,orion_xds=debug".into()))
         .init();
 
     let (delta_resource_tx, delta_resources_rx) = tokio::sync::mpsc::channel(100);
@@ -43,7 +40,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         if delta_resource_tx.send(ServerAction::Add(load_assigment_resource.clone())).await.is_err() {
             return;
-        };
+        }
         tokio::time::sleep(Duration::from_secs(5)).await;
 
         info!("Adding Route configuration  {route_id}");
@@ -54,20 +51,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         if delta_resource_tx.send(ServerAction::Add(route_configuration_resource.clone())).await.is_err() {
             return;
-        };
+        }
 
         tokio::time::sleep(Duration::from_secs(15)).await;
 
         info!("Removing cluster load assignment {cluster_id}");
         if delta_resource_tx.send(ServerAction::Remove(load_assigment_resource)).await.is_err() {
             return;
-        };
+        }
         tokio::time::sleep(Duration::from_secs(5)).await;
 
         info!("Removing route configuration {route_id}");
         if delta_resource_tx.send(ServerAction::Remove(route_configuration_resource)).await.is_err() {
             return;
-        };
+        }
         tokio::time::sleep(Duration::from_secs(5)).await;
     });
 
diff --git a/orion-xds/examples/server_secret_rotation.rs b/orion-xds/examples/server_secret_rotation.rs
index 2505d4b5..493af1c4 100644
--- a/orion-xds/examples/server_secret_rotation.rs
+++ b/orion-xds/examples/server_secret_rotation.rs
@@ -14,10 +14,7 @@ use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilte
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::try_from_default_env()
-                .unwrap_or_else(|_| "info,orion_xds=debug".into()),
-        )
+        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info,orion_xds=debug".into()))
         .init();
 
     let (delta_resource_tx, delta_resources_rx) = tokio::sync::mpsc::channel(100);
@@ -59,7 +56,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         if delta_resource_tx.send(ServerAction::Add(secret_resource.clone())).await.is_err() {
             return;
-        };
+        }
 
         tokio::time::sleep(Duration::from_secs(15)).await;
 
@@ -81,7 +78,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         if delta_resource_tx.send(ServerAction::Add(secret_resource.clone())).await.is_err() {
             return;
-        };
+        }
 
         tokio::time::sleep(Duration::from_secs(15)).await;
     });
diff --git a/orion-xds/src/xds/resources/mod.rs b/orion-xds/src/xds/resources/mod.rs
index 1318b314..cf1b93c6 100644
--- a/orion-xds/src/xds/resources/mod.rs
+++ b/orion-xds/src/xds/resources/mod.rs
@@ -416,7 +416,7 @@ mod test {
 
     #[test]
     fn test_cluster_conversion() {
-        const CLUSTER: &str = r#"
+        const CLUSTER: &str = r"
 name: cluster1
 type: STATIC
 load_assignment:
@@ -427,7 +427,7 @@ load_assignment:
               socket_address:
                 address: 192.168.2.10
                 port_value: 80
-"#;
+";
         let cluster: Cluster = from_yaml(CLUSTER).unwrap();
 
         let mut value: Vec<u8> = vec![];

From bf9aa1a009d1ba69cffbf8b452df7ffeaca9a103 Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Fri, 30 May 2025 16:14:37 +0200
Subject: [PATCH 59/64] Add Service Runtime.

- Create service runtime where to accomodate xds, admin and access
logging.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-configuration/src/config/runtime.rs |   9 ++
 orion-configuration/src/options.rs        |   4 +
 orion-proxy/src/proxy.rs                  | 158 ++++++++++++++--------
 orion-proxy/src/runtime.rs                |  87 +++++-------
 orion-proxy/src/xds_configurator.rs       |   6 +-
 5 files changed, 153 insertions(+), 111 deletions(-)

diff --git a/orion-configuration/src/config/runtime.rs b/orion-configuration/src/config/runtime.rs
index 7f280dbc..33b5840f 100644
--- a/orion-configuration/src/config/runtime.rs
+++ b/orion-configuration/src/config/runtime.rs
@@ -34,6 +34,8 @@ pub struct Runtime {
     pub num_cpus: NonZeroUsize,
     #[serde(default = "one")]
     pub num_runtimes: NonZeroU32,
+    #[serde(default = "one")]
+    pub num_service_threads: NonZeroU32,
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub global_queue_interval: Option<NonZeroU32>,
     #[serde(skip_serializing_if = "Option::is_none", default)]
@@ -59,6 +61,12 @@ impl Runtime {
                 .or(opt.num_cpus)
                 .unwrap_or(self.num_cpus),
 
+            num_service_threads: var("ORION_SERVICE_THREADS")
+                .ok()
+                .and_then(|v| v.parse::<NonZeroU32>().ok())
+                .or_else(|| opt.num_service_threads)
+                .unwrap_or(self.num_service_threads),
+
             num_runtimes: var("ORION_GATEWAY_RUNTIMES")
                 .ok()
                 .and_then(|v| v.parse::<NonZeroU32>().ok())
@@ -106,6 +114,7 @@ impl Default for Runtime {
         Self {
             num_cpus: non_zero_num_cpus(),
             num_runtimes: one(),
+            num_service_threads: one(),
             global_queue_interval: None,
             event_interval: None,
             max_io_events_per_tick: None,
diff --git a/orion-configuration/src/options.rs b/orion-configuration/src/options.rs
index 681ec7f2..184afc7e 100644
--- a/orion-configuration/src/options.rs
+++ b/orion-configuration/src/options.rs
@@ -43,6 +43,8 @@ pub struct Options {
     pub num_cpus: Option<NonZeroUsize>,
     #[arg(help = "Number of Tokio runtimes to use", short = 'R', long = "num-runtimes")]
     pub num_runtimes: Option<NonZeroU32>,
+    #[arg(help = "Number of Service threads to use", short = 'S', long = "num-service-threads")]
+    pub num_service_threads: Option<NonZeroU32>,
     #[arg(help = "Tokio global queue interval (ticks)", long = "global-queue-interval")]
     pub global_queue_interval: Option<NonZeroU32>,
     #[arg(help = "Tokio event interval (ticks)", long = "event-interval")]
@@ -73,6 +75,7 @@ impl Options {
             config_files: ConfigFiles { config: Some(path.into()), bootstrap_override: None },
             num_cpus: None,
             num_runtimes: None,
+            num_service_threads: None,
             global_queue_interval: None,
             event_interval: None,
             max_io_events_per_tick: None,
@@ -85,6 +88,7 @@ impl Options {
             config_files: ConfigFiles { config: None, bootstrap_override: Some(path.into()) },
             num_cpus: None,
             num_runtimes: None,
+            num_service_threads: None,
             global_queue_interval: None,
             event_interval: None,
             max_io_events_per_tick: None,
diff --git a/orion-proxy/src/proxy.rs b/orion-proxy/src/proxy.rs
index 266c20bd..6d199691 100644
--- a/orion-proxy/src/proxy.rs
+++ b/orion-proxy/src/proxy.rs
@@ -24,7 +24,7 @@ use crate::{
     xds_configurator::XdsConfigurationHandler,
 };
 use futures::future::join_all;
-use orion_configuration::config::{bootstrap::Node, Bootstrap};
+use orion_configuration::config::{bootstrap::Node, runtime::Affinity, Bootstrap};
 use orion_error::Context;
 use orion_lib::{
     get_listeners_and_clusters, new_configuration_channel, runtime_config, ConfigurationReceivers,
@@ -34,8 +34,8 @@ use std::{
     sync::atomic::AtomicUsize,
     thread::{self, JoinHandle},
 };
-use tokio::{runtime::Builder, sync::mpsc::Sender};
-use tracing::{debug, error, info, warn};
+use tokio::{runtime::Builder, sync::mpsc::Sender, task::JoinSet};
+use tracing::{debug, info, warn};
 
 pub fn run_proxy(bootstrap: Bootstrap) -> Result<()> {
     debug!("Starting on thread {:?}", std::thread::current().name());
@@ -67,19 +67,35 @@ fn calculate_threads_per_runtime(num_cpus: usize, num_runtimes: usize) -> Result
     Ok(threads)
 }
 
+struct ServiceInfo {
+    node: Node,
+    configuration_senders: Vec<ConfigurationSenders>,
+    secret_manager: SecretManager,
+    listeners: Vec<orion_lib::ListenerFactory>,
+    clusters: Vec<orion_lib::PartialClusterType>,
+    ads_cluster_names: Vec<String>,
+}
+
 fn launch_runtimes(bootstrap: Bootstrap) -> Result<()> {
-    let config = runtime_config();
-    let num_runtimes = config.num_runtimes();
-    let num_cpus = config.num_cpus();
+    let rt_config = runtime_config();
+
+    let num_runtimes = rt_config.num_runtimes();
+    let num_cpus = rt_config.num_cpus();
     info!("Launching with {} cpus, {} runtimes", num_cpus, num_runtimes);
 
     let handles = {
         let num_threads_per_runtime = calculate_threads_per_runtime(num_cpus, num_runtimes)
             .context("failed to calculate number of threads to use per runtime")?;
-        info!("using {} runtimes with {num_threads_per_runtime} threads each", config.num_runtimes());
+        info!("using {} runtimes with {num_threads_per_runtime} threads each", rt_config.num_runtimes());
 
         (0..num_runtimes)
-            .map(|id| spawn_runtime_from_thread(num_threads_per_runtime, RuntimeId(id)))
+            .map(|id| {
+                spawn_proxy_runtime_from_thread(
+                    "proxy",
+                    num_threads_per_runtime,
+                    rt_config.affinity_strategy.clone().map(|affinity| (RuntimeId(id), affinity)),
+                )
+            })
             .collect::<Result<Vec<_>>>()?
     };
 
@@ -105,17 +121,17 @@ fn launch_runtimes(bootstrap: Bootstrap) -> Result<()> {
         return Err("No listeners and no ads clusters configured".into());
     }
 
-    let _guard = match xds_loop(node, configuration_senders, secret_manager, listeners, clusters, ads_cluster_names) {
-        Ok(g) => {
-            debug!("xDS loop finished");
-            g
-        },
-        Err(err) => {
-            error!("xDS loop exited with error: {err}");
-            return Err(err);
-        },
+    let service_info = ServiceInfo {
+        node,
+        configuration_senders: configuration_senders.clone(),
+        secret_manager,
+        listeners,
+        clusters,
+        ads_cluster_names,
     };
 
+    spawn_service_runtime_from_thread("services", rt_config.num_service_threads.get() as usize, None, service_info)?;
+
     for handle in handles {
         if let Err(err) = handle.join() {
             warn!("Closing handler with error {err:?}");
@@ -124,58 +140,84 @@ fn launch_runtimes(bootstrap: Bootstrap) -> Result<()> {
     Ok(())
 }
 
-type RuntimeHandle = (JoinHandle<Result<()>>, ConfigurationSenders);
+type RuntimeHandle = JoinHandle<Result<()>>;
 
-fn spawn_runtime_from_thread(num_threads: usize, runtime_id: RuntimeId) -> Result<RuntimeHandle> {
+fn spawn_proxy_runtime_from_thread(
+    thread_name: &'static str,
+    num_threads: usize,
+    affinity_info: Option<(RuntimeId, Affinity)>,
+) -> Result<(RuntimeHandle, ConfigurationSenders)> {
     let (configuration_senders, configuration_receivers) = new_configuration_channel(100);
 
-    let handle: JoinHandle<Result<()>> =
-        thread::Builder::new().name(format!("proxy_{runtime_id}")).spawn(move || {
-            let rt = runtime::build_tokio_runtime(num_threads, runtime_id);
-            rt.block_on(async {
-                tokio::select! {
-                    _ = start_proxy(configuration_receivers) => {
-                        info!("Proxy Runtime terminated!");
-                        Ok(())
-                    }
-                    _ = tokio::signal::ctrl_c() => {
-                        info!("CTRL+C catch (Proxy runtime)!");
-                        Ok(())
-                    }
+    let thread_name = match &affinity_info {
+        Some((runtime_id, _affinity)) => format!("{thread_name}_RT{runtime_id}"),
+        None => format!("{thread_name}_rt"),
+    };
+
+    let handle: JoinHandle<Result<()>> = thread::Builder::new().name(thread_name.clone()).spawn(move || {
+        let rt = runtime::build_tokio_runtime(&thread_name, num_threads, affinity_info);
+        rt.block_on(async {
+            tokio::select! {
+                _ = start_proxy(configuration_receivers) => {
+                    info!("Proxy Runtime terminated!");
+                    Ok(())
                 }
-            })
-        })?;
+                _ = tokio::signal::ctrl_c() => {
+                    info!("CTRL+C (Proxy runtime)!");
+                    Ok(())
+                }
+            }
+        })
+    })?;
     Ok((handle, configuration_senders))
 }
 
-#[allow(clippy::too_many_arguments)]
-fn xds_loop(
-    node: Node,
-    configuration_senders: Vec<ConfigurationSenders>,
-    secret_manager: SecretManager,
-    listeners: Vec<orion_lib::ListenerFactory>,
-    clusters: Vec<orion_lib::PartialClusterType>,
-    ads_cluster_names: Vec<String>,
-) -> Result<XdsConfigurationHandler> {
-    let mut builder = Builder::new_multi_thread();
-    let runtime = builder
-        .enable_all()
-        .worker_threads(1)
-        .max_blocking_threads(1)
-        .thread_name_fn(|| {
-            static ATOMIC_ID: AtomicUsize = AtomicUsize::new(0);
-            let id = ATOMIC_ID.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-            format!("xdstask_{id}")
+fn spawn_service_runtime_from_thread(
+    thread_name: &'static str,
+    num_threads: usize,
+    affinity_info: Option<(RuntimeId, Affinity)>,
+    service_info: ServiceInfo,
+) -> Result<RuntimeHandle> {
+    let thread_name = match &affinity_info {
+        Some((runtime_id, _affinity)) => format!("{thread_name}_RT{runtime_id}"),
+        None => format!("{thread_name}_rt"),
+    };
+
+    let rt_handle = thread::Builder::new().name(thread_name.clone()).spawn(move || {
+        let rt = runtime::build_tokio_runtime(&thread_name, num_threads, affinity_info);
+        rt.block_on(async {
+            tokio::select! {
+                _ = run_services(service_info) => {
+                    info!("Service Runtime terminated!");
+                    Ok(())
+                }
+                _ = tokio::signal::ctrl_c() => {
+                    info!("CTRL+C (service runtime)!");
+                    Ok(())
+                }
+            }
         })
-        .build()
-        .with_context(|| "failed to build basic runtime")?;
-    runtime.block_on(async move {
+    })?;
+
+    Ok(rt_handle)
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn run_services(info: ServiceInfo) {
+    let ServiceInfo { node, configuration_senders, secret_manager, listeners, clusters, ads_cluster_names } = info;
+    let mut set: JoinSet<Result<()>> = JoinSet::new();
+
+    // spawn XSD configuration service...
+
+    set.spawn(async move {
         let secret_manager =
             configure_initial_resources(secret_manager, listeners, configuration_senders.clone()).await?;
-        let xds_runtime = XdsConfigurationHandler::new(secret_manager, configuration_senders);
+        let xds_handler = XdsConfigurationHandler::new(secret_manager, configuration_senders);
+        _ = xds_handler.xds_run(node, clusters, ads_cluster_names).await;
+        Ok(())
+    });
 
-        xds_runtime.run(node, clusters, ads_cluster_names).await
-    })
+    set.join_all().await;
 }
 
 async fn configure_initial_resources(
diff --git a/orion-proxy/src/runtime.rs b/orion-proxy/src/runtime.rs
index d36cde32..f0d42507 100644
--- a/orion-proxy/src/runtime.rs
+++ b/orion-proxy/src/runtime.rs
@@ -19,6 +19,7 @@
 //
 
 use crate::core_affinity::{self, AffinityStrategy};
+use orion_configuration::config::runtime::Affinity;
 use orion_lib::runtime_config;
 use std::{fmt::Display, ops::Deref};
 use tokio::runtime::{Builder, Runtime};
@@ -43,61 +44,47 @@ impl Deref for RuntimeId {
     }
 }
 
-pub fn build_tokio_runtime(num_threads: usize, runtime_id: RuntimeId) -> Runtime {
-    let thread_name = "proxytask";
+pub fn build_tokio_runtime(
+    thread_name: &str,
+    num_threads: usize,
+    affinity_info: Option<(RuntimeId, Affinity)>,
+) -> Runtime {
     let config = runtime_config();
-    if num_threads == 1 {
-        if let Some(affinity) = &config.affinity_strategy {
-            match affinity.run_strategy(runtime_id, num_threads) {
-                Ok(aff) => {
-                    if let Err(err) = core_affinity::set_cores_for_current(&aff) {
-                        warn!("{thread_name}: Couldn't pin thread to core {aff:?}: {err}");
-                    } else {
-                        info!("{thread_name}: ST-runtime[{runtime_id}] pinned to core {aff:?}");
-                    }
-                },
-                Err(e) => {
-                    warn!("{thread_name}: Strategy: {e}");
-                },
-            }
-        }
 
-        let mut builder = Builder::new_current_thread();
-        builder.enable_all();
+    let thread_name: String = match affinity_info {
+        Some((runtime_id, _)) => format!("{thread_name}_{runtime_id}"),
+        None => thread_name.to_owned(),
+    };
 
-        config.global_queue_interval.map(|val| builder.global_queue_interval(val.into()));
-        config.event_interval.map(|val| builder.event_interval(val));
-        config.max_io_events_per_tick.map(|val| builder.max_io_events_per_tick(val.into()));
-        #[allow(clippy::expect_used)]
-        builder.thread_name(format!("{thread_name}{}", runtime_id.0)).build().expect("failed to build basic runtime")
-    } else {
-        if let Some(affinity) = &config.affinity_strategy {
-            match affinity.run_strategy(runtime_id, num_threads) {
-                Ok(aff) => {
-                    if let Err(err) = core_affinity::set_cores_for_current(&aff) {
-                        warn!("{thread_name}: Couldn't pin thread to core {aff:?}: {err}");
-                    } else {
-                        info!("{thread_name} MT-{num_threads}-runtime[{runtime_id}] pinned to cores {aff:?}");
-                    }
-                },
-                Err(e) => {
-                    warn!("{thread_name}: Strategy: {e}");
-                },
-            }
+    if let Some((runtime_id, affinity)) = affinity_info {
+        match affinity.run_strategy(runtime_id, num_threads) {
+            Ok(aff) => {
+                if let Err(err) = core_affinity::set_cores_for_current(&aff) {
+                    warn!("{thread_name}: Couldn't pin thread to core {aff:?}: {err}");
+                } else {
+                    info!("{thread_name}: ST-runtime[{runtime_id}] pinned to core {aff:?}");
+                }
+            },
+            Err(e) => {
+                warn!("{thread_name}: Strategy: {e}");
+            },
         }
+    }
 
-        let mut builder = Builder::new_multi_thread();
-        builder.enable_all().worker_threads(num_threads).max_blocking_threads(num_threads);
+    let mut builder = if num_threads <= 1 {
+        let mut b = Builder::new_current_thread();
+        b.enable_all();
+        b
+    } else {
+        let mut b = Builder::new_multi_thread();
+        b.worker_threads(num_threads).max_blocking_threads(num_threads).enable_all();
+        b
+    };
 
-        config.global_queue_interval.map(|val| builder.global_queue_interval(val.into()));
-        config.event_interval.map(|val| builder.event_interval(val));
-        config.max_io_events_per_tick.map(|val| builder.max_io_events_per_tick(val.into()));
+    config.global_queue_interval.map(|val| builder.global_queue_interval(val.into()));
+    config.event_interval.map(|val| builder.event_interval(val));
+    config.max_io_events_per_tick.map(|val| builder.max_io_events_per_tick(val.into()));
 
-        let name = thread_name.to_owned();
-        #[allow(clippy::expect_used)]
-        builder
-            .thread_name_fn(move || format!("{name}{}", runtime_id.0))
-            .build()
-            .expect("failed to build threaded runtime")
-    }
+    #[allow(clippy::expect_used)]
+    builder.thread_name(thread_name).build().expect("failed to build basic runtime")
 }
diff --git a/orion-proxy/src/xds_configurator.rs b/orion-proxy/src/xds_configurator.rs
index 9ba0f579..dc239ba4 100644
--- a/orion-proxy/src/xds_configurator.rs
+++ b/orion-proxy/src/xds_configurator.rs
@@ -90,7 +90,7 @@ impl XdsConfigurationHandler {
             .map_err(Into::into)
     }
 
-    pub async fn run(
+    pub async fn xds_run(
         mut self,
         node: Node,
         initial_clusters: Vec<PartialClusterType>,
@@ -98,12 +98,12 @@ impl XdsConfigurationHandler {
     ) -> Result<Self> {
         select! {
             _ = tokio::signal::ctrl_c() => info!("CTRL+C catch (XDS runtime)!"),
-            result = self.run_loop(node, initial_clusters, ads_cluster_names) => result?,
+            result = self.xds_run_loop(node, initial_clusters, ads_cluster_names) => result?,
         }
         Ok(self)
     }
 
-    async fn run_loop(
+    async fn xds_run_loop(
         &mut self,
         node: Node,
         initial_clusters: Vec<PartialClusterType>,

From 38849eddcec280f580cb055116601b559001dcd1 Mon Sep 17 00:00:00 2001
From: Francesco Ciaccia <francesco.ciaccia1@huawei-partners.com>
Date: Fri, 30 May 2025 16:25:09 +0200
Subject: [PATCH 60/64] Fixing clippy warnings.

Signed-off-by: Francesco Ciaccia <francesco.ciaccia1@huawei-partners.com>
---
 orion-configuration/src/config/runtime.rs | 2 +-
 orion-proxy/src/proxy.rs                  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/orion-configuration/src/config/runtime.rs b/orion-configuration/src/config/runtime.rs
index 33b5840f..c6e5446b 100644
--- a/orion-configuration/src/config/runtime.rs
+++ b/orion-configuration/src/config/runtime.rs
@@ -64,7 +64,7 @@ impl Runtime {
             num_service_threads: var("ORION_SERVICE_THREADS")
                 .ok()
                 .and_then(|v| v.parse::<NonZeroU32>().ok())
-                .or_else(|| opt.num_service_threads)
+                .or(opt.num_service_threads)
                 .unwrap_or(self.num_service_threads),
 
             num_runtimes: var("ORION_GATEWAY_RUNTIMES")
diff --git a/orion-proxy/src/proxy.rs b/orion-proxy/src/proxy.rs
index 6d199691..c055cdbf 100644
--- a/orion-proxy/src/proxy.rs
+++ b/orion-proxy/src/proxy.rs
@@ -187,7 +187,7 @@ fn spawn_service_runtime_from_thread(
         let rt = runtime::build_tokio_runtime(&thread_name, num_threads, affinity_info);
         rt.block_on(async {
             tokio::select! {
-                _ = run_services(service_info) => {
+                () = run_services(service_info) => {
                     info!("Service Runtime terminated!");
                     Ok(())
                 }

From 3e67ec8aaefac48c8acc4ddb935ec0aeeee6f48f Mon Sep 17 00:00:00 2001
From: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
Date: Thu, 29 May 2025 10:19:23 +0200
Subject: [PATCH 61/64] Add Clone trait to bootsrap configuration and refactor
 ServiceInfo

- Refactored ServiceInfo to include the entire Bootstrap struct instead
of duplicating listeners. Updated related function calls and logic
to use Bootstrap directly.
- Bootstrap in ServiceInfo is currently not used in run_services but
it will be needed when adding access_log and admin tasks.

Signed-off-by: Nicola Bonelli <nicola.bonelli@huawei-partners.com>
---
 orion-configuration/src/config/bootstrap.rs |  8 +++----
 orion-configuration/src/config/secret.rs    |  4 ++--
 orion-proxy/src/proxy.rs                    | 24 +++++++++++++++------
 3 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/orion-configuration/src/config/bootstrap.rs b/orion-configuration/src/config/bootstrap.rs
index ccee967b..a03286a7 100644
--- a/orion-configuration/src/config/bootstrap.rs
+++ b/orion-configuration/src/config/bootstrap.rs
@@ -22,12 +22,12 @@ use crate::config::{cluster::Cluster, common::is_default, listener::Listener, se
 use compact_str::CompactString;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize, Default, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
 pub struct Bootstrap {
     #[serde(with = "serde_yaml::with::singleton_map_recursive", skip_serializing_if = "is_default", default)]
     pub static_resources: StaticResources,
     #[serde(skip_serializing_if = "Option::is_none", default = "Default::default")]
-    dynamic_resources: Option<DynamicResources>,
+    pub dynamic_resources: Option<DynamicResources>,
     #[serde(skip_serializing_if = "Option::is_none", default = "Default::default")]
     pub node: Option<Node>,
 }
@@ -43,12 +43,12 @@ pub struct Node {
     pub id: CompactString,
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct DynamicResources {
     pub grpc_cluster_specifiers: Vec<CompactString>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Default, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
 pub struct StaticResources {
     #[serde(skip_serializing_if = "Vec::is_empty", default = "Default::default")]
     pub listeners: Vec<Listener>,
diff --git a/orion-configuration/src/config/secret.rs b/orion-configuration/src/config/secret.rs
index fca5c990..c6bdbf31 100644
--- a/orion-configuration/src/config/secret.rs
+++ b/orion-configuration/src/config/secret.rs
@@ -23,7 +23,7 @@ use compact_str::CompactString;
 use serde::{Deserialize, Serialize};
 use std::fmt::Debug;
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Secret {
     name: CompactString,
     #[serde(flatten)]
@@ -40,7 +40,7 @@ impl Secret {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
 pub enum Type {
     TlsCertificate(TlsCertificate),
diff --git a/orion-proxy/src/proxy.rs b/orion-proxy/src/proxy.rs
index c055cdbf..bd344a79 100644
--- a/orion-proxy/src/proxy.rs
+++ b/orion-proxy/src/proxy.rs
@@ -68,10 +68,11 @@ fn calculate_threads_per_runtime(num_cpus: usize, num_runtimes: usize) -> Result
 }
 
 struct ServiceInfo {
+    bootstrap: Bootstrap,
     node: Node,
     configuration_senders: Vec<ConfigurationSenders>,
     secret_manager: SecretManager,
-    listeners: Vec<orion_lib::ListenerFactory>,
+    listener_factories: Vec<orion_lib::ListenerFactory>,
     clusters: Vec<orion_lib::PartialClusterType>,
     ads_cluster_names: Vec<String>,
 }
@@ -114,10 +115,10 @@ fn launch_runtimes(bootstrap: Bootstrap) -> Result<()> {
     let ads_cluster_names: Vec<String> = bootstrap.get_ads_configs().iter().map(ToString::to_string).collect();
     let node = bootstrap.node.clone().unwrap_or_else(|| Node { id: "".into() });
 
-    let (secret_manager, listeners, clusters) =
-        get_listeners_and_clusters(bootstrap).context("Failed to get listeners and clusters")?;
+    let (secret_manager, listener_factories, clusters) =
+        get_listeners_and_clusters(bootstrap.clone()).context("Failed to get listeners and clusters")?;
 
-    if listeners.is_empty() && ads_cluster_names.is_empty() {
+    if listener_factories.is_empty() && ads_cluster_names.is_empty() {
         return Err("No listeners and no ads clusters configured".into());
     }
 
@@ -125,7 +126,8 @@ fn launch_runtimes(bootstrap: Bootstrap) -> Result<()> {
         node,
         configuration_senders: configuration_senders.clone(),
         secret_manager,
-        listeners,
+        listener_factories,
+        bootstrap,
         clusters,
         ads_cluster_names,
     };
@@ -204,14 +206,22 @@ fn spawn_service_runtime_from_thread(
 
 #[allow(clippy::too_many_arguments)]
 async fn run_services(info: ServiceInfo) {
-    let ServiceInfo { node, configuration_senders, secret_manager, listeners, clusters, ads_cluster_names } = info;
+    let ServiceInfo {
+        bootstrap: _,
+        node,
+        configuration_senders,
+        secret_manager,
+        listener_factories,
+        clusters,
+        ads_cluster_names,
+    } = info;
     let mut set: JoinSet<Result<()>> = JoinSet::new();
 
     // spawn XSD configuration service...
 
     set.spawn(async move {
         let secret_manager =
-            configure_initial_resources(secret_manager, listeners, configuration_senders.clone()).await?;
+            configure_initial_resources(secret_manager, listener_factories, configuration_senders.clone()).await?;
         let xds_handler = XdsConfigurationHandler::new(secret_manager, configuration_senders);
         _ = xds_handler.xds_run(node, clusters, ads_cluster_names).await;
         Ok(())

From 9b199727f4157dfc8fbba7f05c45f5558638f158 Mon Sep 17 00:00:00 2001
From: Francesco Ciaccia <francesco.ciaccia1@huawei-partners.com>
Date: Thu, 21 Aug 2025 18:08:05 +0200
Subject: [PATCH 62/64] Update dependencies and clean up imports.

- Added `tracing-subscriber` to dependencies in `Cargo.lock` and `Cargo.toml`.
- Introduced a test route name in `http_connection_manager.rs`.
- Refactored allocator configuration in `main.rs` to prevent simultaneous feature usage.
- Removed unused imports of `tracing_subscriber` in several example files.

Signed-off-by: Francesco Ciaccia <francesco.ciaccia1@huawei-partners.com>
---
 Cargo.lock                                             |  1 +
 .../config/network_filters/http_connection_manager.rs  |  1 +
 orion-proxy/src/main.rs                                | 10 ++++------
 orion-proxy/src/proxy.rs                               |  3 +--
 orion-xds/Cargo.toml                                   |  1 +
 orion-xds/examples/client.rs                           |  1 -
 orion-xds/examples/server.rs                           |  1 -
 orion-xds/examples/server_routes_and_loads.rs          |  2 +-
 orion-xds/examples/server_secret_rotation.rs           |  2 +-
 9 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f5bdcc0b..08730b75 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2007,6 +2007,7 @@ dependencies = [
  "tokio-stream",
  "tower 0.5.2",
  "tracing",
+ "tracing-subscriber",
  "uuid",
 ]
 
diff --git a/orion-configuration/src/config/network_filters/http_connection_manager.rs b/orion-configuration/src/config/network_filters/http_connection_manager.rs
index 94fafbdc..15b3bcd7 100644
--- a/orion-configuration/src/config/network_filters/http_connection_manager.rs
+++ b/orion-configuration/src/config/network_filters/http_connection_manager.rs
@@ -649,6 +649,7 @@ mod tests {
     #[test]
     fn test_unfold_upgrades() {
         let route_a = Route {
+            name: "test_route".to_string(),
             response_header_modifier: HeaderModifier::default(),
             request_headers_to_add: vec![],
             request_headers_to_remove: vec![],
diff --git a/orion-proxy/src/main.rs b/orion-proxy/src/main.rs
index 02af160a..adb11092 100644
--- a/orion-proxy/src/main.rs
+++ b/orion-proxy/src/main.rs
@@ -18,9 +18,6 @@
 //
 //
 
-#[cfg(all(feature = "jemalloc", feature = "dhat-heap"))]
-compile_error!("feature \"jemalloc\" and feature \"dhat-heap\" cannot be enabled at the same time");
-
 #[cfg(all(feature = "jemalloc", not(target_env = "msvc")))]
 use tikv_jemallocator::Jemalloc;
 
@@ -28,11 +25,12 @@ use tikv_jemallocator::Jemalloc;
 #[global_allocator]
 static GLOBAL: Jemalloc = Jemalloc;
 
-#[cfg(feature = "dhat-heap")]
+#[cfg(all(feature = "dhat-heap", not(feature = "jemalloc")))]
 #[global_allocator]
 static ALLOC: dhat::Alloc = dhat::Alloc;
+
 fn main() -> orion_error::Result<()> {
-    #[cfg(feature = "dhat-heap")]
+    #[cfg(all(feature = "dhat-heap", not(feature = "jemalloc")))]
     let _profiler = dhat::Profiler::new_heap();
     orion_proxy::run()
-}
+}
\ No newline at end of file
diff --git a/orion-proxy/src/proxy.rs b/orion-proxy/src/proxy.rs
index bd344a79..67e5ea29 100644
--- a/orion-proxy/src/proxy.rs
+++ b/orion-proxy/src/proxy.rs
@@ -31,10 +31,9 @@ use orion_lib::{
     ConfigurationSenders, ListenerConfigurationChange, Result, SecretManager,
 };
 use std::{
-    sync::atomic::AtomicUsize,
     thread::{self, JoinHandle},
 };
-use tokio::{runtime::Builder, sync::mpsc::Sender, task::JoinSet};
+use tokio::{sync::mpsc::Sender, task::JoinSet};
 use tracing::{debug, info, warn};
 
 pub fn run_proxy(bootstrap: Bootstrap) -> Result<()> {
diff --git a/orion-xds/Cargo.toml b/orion-xds/Cargo.toml
index 6c376f54..f55f1022 100644
--- a/orion-xds/Cargo.toml
+++ b/orion-xds/Cargo.toml
@@ -25,6 +25,7 @@ uuid                   = { version = "1.7.0", features = ["v4"] }
 
 [dev-dependencies]
 serde_yaml.workspace = true
+tracing-subscriber.workspace = true
 
 [lints]
 workspace = true
diff --git a/orion-xds/examples/client.rs b/orion-xds/examples/client.rs
index d4480939..431703a3 100644
--- a/orion-xds/examples/client.rs
+++ b/orion-xds/examples/client.rs
@@ -6,7 +6,6 @@ use orion_xds::{
 };
 use std::future::IntoFuture;
 use tracing::{debug, info};
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 use tracing_subscriber::EnvFilter;
 
diff --git a/orion-xds/examples/server.rs b/orion-xds/examples/server.rs
index 08843b0d..69caebe3 100644
--- a/orion-xds/examples/server.rs
+++ b/orion-xds/examples/server.rs
@@ -1,7 +1,6 @@
 use orion_data_plane_api::envoy_data_plane_api::envoy::extensions::filters::network::http_connection_manager::v3::http_connection_manager::CodecType;
 use orion_xds::xds::{resources, server::{start_aggregate_server, ServerAction}};
 use tracing::info;
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 use std::{future::IntoFuture, time::Duration};
 use tracing_subscriber::EnvFilter;
 
diff --git a/orion-xds/examples/server_routes_and_loads.rs b/orion-xds/examples/server_routes_and_loads.rs
index aec54131..e5a8b96d 100644
--- a/orion-xds/examples/server_routes_and_loads.rs
+++ b/orion-xds/examples/server_routes_and_loads.rs
@@ -6,7 +6,7 @@ use orion_xds::xds::{
     server::{start_aggregate_server, ServerAction},
 };
 use tracing::info;
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+use tracing_subscriber::{EnvFilter};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
diff --git a/orion-xds/examples/server_secret_rotation.rs b/orion-xds/examples/server_secret_rotation.rs
index 493af1c4..350ad6ef 100644
--- a/orion-xds/examples/server_secret_rotation.rs
+++ b/orion-xds/examples/server_secret_rotation.rs
@@ -9,7 +9,7 @@ use orion_xds::xds::{
     server::{start_aggregate_server, ServerAction},
 };
 use tracing::info;
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+use tracing_subscriber::{EnvFilter};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {

From 22301c9adce8ddd3fe67425227890c12017b6b7a Mon Sep 17 00:00:00 2001
From: Francesco Ciaccia <francesco.ciaccia1@huawei-partners.com>
Date: Fri, 22 Aug 2025 12:04:30 +0200
Subject: [PATCH 63/64] Refactor Cargo.toml.

- Removed files for specific versioning for dependencies and clean up unused
  entries.

Signed-off-by: Francesco Ciaccia <francesco.ciaccia1@huawei-partners.com>
---
 Cargo.lock                      |  99 +++---------------
 Cargo.toml                      | 171 +++++++++++++++++++-------------
 clippy.toml                     |   2 +
 orion-data-plane-api/Cargo.toml |   1 -
 orion-format/Cargo.toml         |   1 -
 orion-lib/Cargo.toml            |   9 --
 orion-proxy/Cargo.toml          |   3 -
 orion-xds/Cargo.toml            |   1 -
 8 files changed, 118 insertions(+), 169 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 08730b75..ce5e5c93 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -136,7 +136,7 @@ dependencies = [
  "nom",
  "num-traits",
  "rusticata-macros",
- "thiserror 1.0.69",
+ "thiserror",
  "time",
 ]
 
@@ -394,7 +394,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "190baaad529bcfbde9e1a19022c42781bdb6ff9de25721abdb8fd98c0807730b"
 dependencies = [
  "libc",
- "thiserror 1.0.69",
+ "thiserror",
 ]
 
 [[package]]
@@ -1115,7 +1115,7 @@ dependencies = [
  "ipnet",
  "once_cell",
  "rand",
- "thiserror 1.0.69",
+ "thiserror",
  "tinyvec",
  "tokio",
  "tracing",
@@ -1138,7 +1138,7 @@ dependencies = [
  "rand",
  "resolv-conf",
  "smallvec",
- "thiserror 1.0.69",
+ "thiserror",
  "tokio",
  "tracing",
 ]
@@ -1284,7 +1284,6 @@ version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d9b05277c7e8da2c93a568989bb6207bef0112e8d17df7a6eda4a3cf143bc5e"
 dependencies = [
- "base64 0.22.1",
  "bytes",
  "futures-channel",
  "futures-core",
@@ -1292,16 +1291,12 @@ dependencies = [
  "http",
  "http-body",
  "hyper",
- "ipnet",
  "libc",
- "percent-encoding",
  "pin-project-lite",
  "socket2 0.6.0",
- "system-configuration",
  "tokio",
  "tower-service",
  "tracing",
- "windows-registry",
 ]
 
 [[package]]
@@ -1547,7 +1542,7 @@ dependencies = [
  "combine",
  "jni-sys",
  "log",
- "thiserror 1.0.69",
+ "thiserror",
  "walkdir",
 ]
 
@@ -1843,7 +1838,6 @@ dependencies = [
  "bytes",
  "clap",
  "compact_str",
- "envoy-data-plane-api",
  "exponential-backoff",
  "http",
  "http-serde-ext",
@@ -1857,7 +1851,7 @@ dependencies = [
  "serde_path_to_error",
  "serde_regex",
  "serde_yaml",
- "thiserror 2.0.16",
+ "thiserror",
  "tracing",
  "tracing-subscriber",
  "tracing-test",
@@ -1875,10 +1869,9 @@ dependencies = [
  "hyper-util",
  "serde",
  "serde_yaml",
- "thiserror 2.0.16",
+ "thiserror",
  "tokio",
  "tokio-stream",
- "tokio-util",
  "tower 0.5.2",
  "tracing",
 ]
@@ -1893,7 +1886,6 @@ version = "0.1.0"
 dependencies = [
  "bitflags",
  "chrono",
- "compact_str",
  "criterion",
  "dhat",
  "http",
@@ -1905,7 +1897,7 @@ dependencies = [
  "smol_str",
  "strum",
  "strum_macros",
- "thiserror 2.0.16",
+ "thiserror",
 ]
 
 [[package]]
@@ -1913,14 +1905,11 @@ name = "orion-lib"
 version = "0.1.0"
 dependencies = [
  "abort-on-drop",
- "async-stream",
  "atomic-time",
  "bytes",
  "compact_str",
  "enum_dispatch",
- "exponential-backoff",
  "futures",
- "futures-util",
  "h2",
  "hickory-resolver",
  "http",
@@ -1929,8 +1918,6 @@ dependencies = [
  "hyper",
  "hyper-rustls",
  "hyper-util",
- "ipnet",
- "once_cell",
  "orion-configuration",
  "orion-data-plane-api",
  "orion-error",
@@ -1940,7 +1927,6 @@ dependencies = [
  "pingora-timeout",
  "pretty-duration",
  "rand",
- "regex",
  "rustc-hash 2.1.1",
  "rustls",
  "rustls-pemfile",
@@ -1948,18 +1934,15 @@ dependencies = [
  "rustls-webpki 0.102.8",
  "serde",
  "serde_yaml",
- "thiserror 2.0.16",
+ "thiserror",
  "thread_local",
  "tokio",
  "tokio-rustls",
- "tokio-stream",
  "tower 0.5.2",
- "tower-service",
  "tracing",
  "tracing-test",
  "twox-hash",
  "typed-builder",
- "url",
  "x509-parser",
 ]
 
@@ -1973,13 +1956,10 @@ dependencies = [
  "console-subscriber",
  "dhat",
  "futures",
- "num_cpus",
  "orion-configuration",
  "orion-error",
  "orion-lib",
  "orion-xds",
- "regex",
- "serde",
  "tikv-jemallocator",
  "tokio",
  "tracing",
@@ -1994,7 +1974,6 @@ version = "0.1.0"
 dependencies = [
  "async-stream",
  "atomic-take",
- "bytes",
  "futures",
  "http",
  "orion-configuration",
@@ -2002,7 +1981,7 @@ dependencies = [
  "orion-error",
  "serde",
  "serde_yaml",
- "thiserror 2.0.16",
+ "thiserror",
  "tokio",
  "tokio-stream",
  "tower 0.5.2",
@@ -2855,27 +2834,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "system-configuration"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
-dependencies = [
- "bitflags",
- "core-foundation 0.9.4",
- "system-configuration-sys",
-]
-
-[[package]]
-name = "system-configuration-sys"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
 [[package]]
 name = "tempfile"
 version = "3.21.0"
@@ -2895,16 +2853,7 @@ version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
- "thiserror-impl 1.0.69",
-]
-
-[[package]]
-name = "thiserror"
-version = "2.0.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3467d614147380f2e4e374161426ff399c91084acd2363eaf549172b3d5e60c0"
-dependencies = [
- "thiserror-impl 2.0.16",
+ "thiserror-impl",
 ]
 
 [[package]]
@@ -2918,17 +2867,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "thiserror-impl"
-version = "2.0.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c5e1be1c48b9172ee610da68fd9cd2770e7a4056cb3fc98710ee6906f0c7960"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "thousands"
 version = "0.2.0"
@@ -3219,7 +3157,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3566e8ce28cc0a3fe42519fc80e6b4c943cc4c8cef275620eb8dac2d3d4e06cf"
 dependencies = [
  "crossbeam-channel",
- "thiserror 1.0.69",
+ "thiserror",
  "time",
  "tracing-subscriber",
 ]
@@ -3600,17 +3538,6 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
 
-[[package]]
-name = "windows-registry"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
-dependencies = [
- "windows-link",
- "windows-result",
- "windows-strings",
-]
-
 [[package]]
 name = "windows-result"
 version = "0.3.4"
@@ -3889,7 +3816,7 @@ dependencies = [
  "nom",
  "oid-registry",
  "rusticata-macros",
- "thiserror 1.0.69",
+ "thiserror",
  "time",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 12fd0f4c..67a8399b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,98 +4,133 @@ members = [
   "orion-configuration",
   "orion-data-plane-api",
   "orion-error",
+  "orion-format",
   "orion-lib",
   "orion-proxy",
-  "orion-format",
   "orion-xds",
 ]
+
+
 resolver = "2"
 
+
+[workspace.package]
+description  = "Orion Proxy is a highly experimental cloud native proxy. Orion Proxy is configurable via Envoy xDS protocol"
+edition      = "2021"
+license-file = "./LICENSE"
+rust-version = "1.84"
+version      = "0.1.0"
+
+
+
 [workspace.dependencies]
 envoy-data-plane-api = { path = "envoy-data-plane-api" }
-orion-configuration = { path = "orion-configuration" }
+orion-configuration  = { path = "orion-configuration" }
 orion-data-plane-api = { path = "orion-data-plane-api" }
-orion-error = { path = "orion-error" }
-orion-format = { path = "orion-format" }
-orion-lib = { path = "orion-lib" }
-orion-xds = { path = "orion-xds" }
-
+orion-error          = { path = "orion-error" }
+orion-format         = { path = "orion-format" }
+orion-lib            = { path = "orion-lib" }
+orion-xds            = { path = "orion-xds" }
 
-abort-on-drop = "0.2"
-bytes = "1"
-compact_str = { version = "0.8.0", features = ["serde"] }
-enum_dispatch = "0.3.13"
+abort-on-drop       = "0.2"
+bytes               = "1"
+compact_str         = { version = "0.8.0", features = ["serde"] }
 exponential-backoff = "1.2.0"
-futures = "0.3"
-http = "1.0"
-http-body = "1.0"
-http-body-util = "0.1.0"
-hyper-util = { version = "0.1.3", features = ["full"] }
-num_cpus = "1"
-parking_lot = "0.12.3"
-prost = "0.13"
-prost-build = "^0.13"
-prost-reflect = { version = "0.14", features = ["derive", "serde"] }
-regex = "1.10.2"
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-serde_yaml = "0.9.34"
-thiserror = "2.0"
-tokio = { version = "1.41", features = ["full"] }
-tokio-stream = { version = "0.1.17", features = ["net", "sync"] }
-tonic = "^0.12"
-tonic-build = "^0.12"
-tonic-health = "^0.12"
-tower = { version = "0.5.1", features = ["make"] }
-tracing = "0.1"
-tracing-subscriber = "0.3"
-tracing-test = { version = "0.2", features = ["no-env-filter"] }
-url = "2"
+futures             = "0.3"
+http                = "1.0"
+http-body           = "1.0"
+http-body-util      = "0.1.0"
+hyper-util          = { version = "0.1.15" }
+num_cpus            = "1"
+ppp                 = "2.3"
+prost               = "0.13"
+prost-build         = "^0.13"
+prost-reflect       = { version = "0.14", features = ["derive", "serde"] }
+regex               = "1.10.2"
+serde               = { version = "1", features = ["derive", "rc"] }
+serde_json          = { version = "1" }
+serde_yaml          = "0.9.34"
+thiserror           = "1.0.57"
+tokio               = { version = "1.37", features = ["full"] }
+tokio-stream        = { version = "0.1.15", features = ["net", "sync"] }
+tonic               = "^0.12"
+tonic-build         = "^0.12"
+tonic-health        = "^0.12"
+tower               = { version = "0.5.1", features = ["make"] }
+tracing             = "0.1"
+tracing-subscriber  = "0.3"
+tracing-test        = { version = "0.2", features = ["no-env-filter"] }
+url                 = "2"
 
 
 [profile.release]
-codegen-units = 1
-debug = false
+codegen-units    = 1
+debug            = false
 debug-assertions = false
-incremental = false
-lto = true
-opt-level = 3
-overflow-checks = false
-panic = 'unwind'
-rpath = false
-strip = "debuginfo"
+incremental      = false
+lto              = true
+opt-level        = 3
+overflow-checks  = false
+panic            = 'unwind'
+rpath            = false
+strip            = "debuginfo"
 
 [profile.release-debuginfo]
-debug = "full"
-inherits = "release"
+debug           = "full"
+inherits        = "release"
 split-debuginfo = "packed"
-strip = false
+strip           = false
 
 [profile.release-dhat]
-debug = 1
+debug    = 1
 inherits = "release"
 
 [profile.bench]
 inherits = "release"
 
 [workspace.lints.clippy]
-pedantic = { level = "warn", priority = -1 }
-disallowed-methods      = "deny"
-expect_used             = "warn" # FIXME this should be deny
-correctness             = { level = "deny", priority = 10 }
-panic			= "warn" # FIXME this should be deny
-todo                    = "deny"
-transmute_ptr_to_ptr    = "deny"
+correctness                    = { level = "deny", priority = 10 }
+disallowed-methods             = "deny"
+expect_used                    = "warn"                            # FIXME this should be deny
+panic                          = "warn"                            # FIXME this should be deny
+todo                           = "deny"
+transmute_ptr_to_ptr           = "deny"
 unchecked_duration_subtraction = "deny"
-unused_async            = "deny"
-unwrap_used             = "deny"
-uninlined_format_args   = "deny"
-len_without_is_empty    = "deny"
-trivially_copy_pass_by_ref = "allow"
-map_unwrap_or = "allow"
-into_iter_on_ref        = "allow"
-inconsistent_struct_constructor = "allow"
-semicolon-if-nothing-returned = "allow"
-missing_errors_doc      = "allow"
-must_use_candidate      = "allow"
-doc_markdown            = "allow"
+unused_async                   = "deny"
+unwrap_used                    = "deny"
+
+# A subset of pedantic as warn
+cast_lossless                      = "warn"
+cast_possible_truncation           = "warn"
+cast_possible_wrap                 = "warn"
+cast_precision_loss                = "warn"
+cast_ptr_alignment                 = "warn"
+cast_sign_loss                     = "warn"
+checked_conversions                = "warn"
+if_then_some_else_none             = "warn"
+inconsistent_struct_constructor    = "allow"
+invalid_upcast_comparisons         = "warn"
+large_futures                      = "warn"
+large_stack_arrays                 = "warn"
+large_types_passed_by_value        = "warn"
+map_unwrap_or                      = "allow"
+maybe_infinite_iter                = "warn"
+missing_errors_doc                 = "allow"
+missing_panics_doc                 = "allow"
+module_name_repetitions            = "allow"
+must_use_candidate                 = "allow"
+needless_raw_string_hashes         = "allow"
+pedantic                           = { level = "warn", priority = -1 }
+print_stderr                       = "warn"
+print_stdout                       = "warn"
+ptr_cast_constness                 = "warn"
+range_minus_one                    = "warn"
+range_plus_one                     = "warn"
+redundant_closure_for_method_calls = "warn"
+return_self_not_must_use           = "warn"
+same_functions_in_if_condition     = "warn"
+semicolon-if-nothing-returned      = "allow"
+similar_names                      = "warn"
+str_to_string                      = "warn"
+string_to_string                   = "warn"
+unicode_not_nfc                    = "warn"
diff --git a/clippy.toml b/clippy.toml
index dde7ef14..106a4e09 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -6,6 +6,8 @@ disallowed-methods = [
   { path = "tokio::time::timeout", reason = "Use pingora_timeout::fast_timeout::fast_timeout instead" },
 ]
 
+# The maximum number of function parameters is 5.
+too-many-arguments-threshold = 5
 
 allow-expect-in-tests = true
 allow-print-in-tests = true
diff --git a/orion-data-plane-api/Cargo.toml b/orion-data-plane-api/Cargo.toml
index 92a86ece..e641d139 100644
--- a/orion-data-plane-api/Cargo.toml
+++ b/orion-data-plane-api/Cargo.toml
@@ -16,7 +16,6 @@ serde_yaml.workspace           = true
 thiserror.workspace            = true
 tokio.workspace                = true
 tokio-stream.workspace         = true
-tokio-util                     = "0.7.13"
 tower.workspace                = true
 tracing.workspace              = true
 
diff --git a/orion-format/Cargo.toml b/orion-format/Cargo.toml
index 254f298b..af34d952 100644
--- a/orion-format/Cargo.toml
+++ b/orion-format/Cargo.toml
@@ -18,7 +18,6 @@ chrono = "0.4.40"
 dhat = "0.3.3"
 bitflags = "2.9.0"
 itoa = "1.0.15"
-compact_str = "0.8.0"
 serde = { workspace = true, features = ["rc"] }
 http-serde-ext = "1.0.2"
 strum = { version = "0.27.1", features = ["derive"] }
diff --git a/orion-lib/Cargo.toml b/orion-lib/Cargo.toml
index bab0acbd..0badce82 100644
--- a/orion-lib/Cargo.toml
+++ b/orion-lib/Cargo.toml
@@ -6,14 +6,11 @@ version = "0.1.0"
 
 [dependencies]
 abort-on-drop.workspace       = true
-async-stream                  = "0.3"
 atomic-time                   = "0.1.4"
 bytes.workspace               = true
 compact_str.workspace         = true
 enum_dispatch                 = "0.3.13"
-exponential-backoff.workspace = true
 futures.workspace             = true
-futures-util                  = { version = "0.3", default-features = false }
 h2                            = "0.4.5"
 hickory-resolver              = { version = "0.24", features = ["system-config"] }
 http.workspace                = true
@@ -22,8 +19,6 @@ http-body-util.workspace      = true
 hyper                         = { version = "1", features = ["full"] }
 hyper-rustls                  = { version = "0.27.1", features = ["default", "http2"] }
 hyper-util.workspace          = true
-ipnet                         = "2.9"
-once_cell                     = { version = "1.19" }
 orion-configuration.workspace = true
 orion-error.workspace         = true
 orion-xds.workspace           = true
@@ -32,7 +27,6 @@ pin-project                   = "1.1.5"
 pingora-timeout               = "0.3.0"
 pretty-duration               = "0.1.1"
 rand                          = { version = "0.8.5", features = ["small_rng"] }
-regex.workspace               = true
 rustc-hash                    = "2.1.1"
 rustls                        = "0.23"
 rustls-pemfile                = "2.1"
@@ -43,13 +37,10 @@ thiserror.workspace           = true
 thread_local                  = "1.1.8"
 tokio.workspace               = true
 tokio-rustls                  = "0.26"
-tokio-stream.workspace        = true
 tower.workspace               = true
-tower-service                 = "0.3.2"
 tracing.workspace             = true
 twox-hash                     = "1.6.3"
 typed-builder                 = "0.18.2"
-url.workspace                 = true
 x509-parser                   = { version = "0.16", features = ["default"] }
 
 [dev-dependencies]
diff --git a/orion-proxy/Cargo.toml b/orion-proxy/Cargo.toml
index 2d84b619..2adff5c3 100644
--- a/orion-proxy/Cargo.toml
+++ b/orion-proxy/Cargo.toml
@@ -21,7 +21,6 @@ dhat = { version = "0.3.3", optional = true }
 
 abort-on-drop.workspace       = true
 futures.workspace             = true
-num_cpus.workspace            = true
 orion-configuration.workspace = true
 orion-error.workspace         = true
 orion-lib.workspace           = true
@@ -31,8 +30,6 @@ tracing.workspace             = true
 
 affinity = "0.1.2"
 console-subscriber = { version = "0.4.0", optional = true }
-regex = "1.10.2"
-serde = { version = "1.0", features = ["rc"] }
 tracing-appender = "0.2"
 tracing-subscriber = { workspace = true, features = [
   "alloc",
diff --git a/orion-xds/Cargo.toml b/orion-xds/Cargo.toml
index f55f1022..380e0acb 100644
--- a/orion-xds/Cargo.toml
+++ b/orion-xds/Cargo.toml
@@ -5,7 +5,6 @@ publish = ["rust-inhuawei-com"]
 version = "0.1.0"
 
 [dependencies]
-bytes.workspace                = true
 futures.workspace              = true
 http.workspace                 = true
 orion-configuration.workspace  = true

From 9b97fe9a51650db44df0d4349f529661108e97e2 Mon Sep 17 00:00:00 2001
From: Francesco Ciaccia <francesco.ciaccia1@huawei-partners.com>
Date: Mon, 25 Aug 2025 12:31:23 +0200
Subject: [PATCH 64/64] Cargo fmt and minor miscellanous fixes.

Signed-off-by: Francesco Ciaccia <francesco.ciaccia1@huawei-partners.com>
---
 .gitignore                                    | 1 -
 Cargo.lock                                    | 1 +
 Cargo.toml                                    | 2 +-
 orion-proxy/src/main.rs                       | 2 +-
 orion-proxy/src/proxy.rs                      | 4 +---
 orion-xds/examples/server_routes_and_loads.rs | 2 +-
 orion-xds/examples/server_secret_rotation.rs  | 2 +-
 7 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/.gitignore b/.gitignore
index 0f00098d..d6a8c164 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,4 @@
 /target
-advisory-db
 .idea/
 *.profraw
 *~
diff --git a/Cargo.lock b/Cargo.lock
index ce5e5c93..8211a278 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1838,6 +1838,7 @@ dependencies = [
  "bytes",
  "clap",
  "compact_str",
+ "envoy-data-plane-api",
  "exponential-backoff",
  "http",
  "http-serde-ext",
diff --git a/Cargo.toml b/Cargo.toml
index 67a8399b..e3cd1b09 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,7 @@ resolver = "2"
 
 
 [workspace.package]
-description  = "Orion Proxy is a highly experimental cloud native proxy. Orion Proxy is configurable via Envoy xDS protocol"
+description  = "Orion Proxy is a cloud native proxy. Orion Proxy is configurable via Envoy xDS protocol"
 edition      = "2021"
 license-file = "./LICENSE"
 rust-version = "1.84"
diff --git a/orion-proxy/src/main.rs b/orion-proxy/src/main.rs
index adb11092..331284b6 100644
--- a/orion-proxy/src/main.rs
+++ b/orion-proxy/src/main.rs
@@ -33,4 +33,4 @@ fn main() -> orion_error::Result<()> {
     #[cfg(all(feature = "dhat-heap", not(feature = "jemalloc")))]
     let _profiler = dhat::Profiler::new_heap();
     orion_proxy::run()
-}
\ No newline at end of file
+}
diff --git a/orion-proxy/src/proxy.rs b/orion-proxy/src/proxy.rs
index 67e5ea29..c0d91f67 100644
--- a/orion-proxy/src/proxy.rs
+++ b/orion-proxy/src/proxy.rs
@@ -30,9 +30,7 @@ use orion_lib::{
     get_listeners_and_clusters, new_configuration_channel, runtime_config, ConfigurationReceivers,
     ConfigurationSenders, ListenerConfigurationChange, Result, SecretManager,
 };
-use std::{
-    thread::{self, JoinHandle},
-};
+use std::thread::{self, JoinHandle};
 use tokio::{sync::mpsc::Sender, task::JoinSet};
 use tracing::{debug, info, warn};
 
diff --git a/orion-xds/examples/server_routes_and_loads.rs b/orion-xds/examples/server_routes_and_loads.rs
index e5a8b96d..b334e4d1 100644
--- a/orion-xds/examples/server_routes_and_loads.rs
+++ b/orion-xds/examples/server_routes_and_loads.rs
@@ -6,7 +6,7 @@ use orion_xds::xds::{
     server::{start_aggregate_server, ServerAction},
 };
 use tracing::info;
-use tracing_subscriber::{EnvFilter};
+use tracing_subscriber::EnvFilter;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
diff --git a/orion-xds/examples/server_secret_rotation.rs b/orion-xds/examples/server_secret_rotation.rs
index 350ad6ef..f8fd59df 100644
--- a/orion-xds/examples/server_secret_rotation.rs
+++ b/orion-xds/examples/server_secret_rotation.rs
@@ -9,7 +9,7 @@ use orion_xds::xds::{
     server::{start_aggregate_server, ServerAction},
 };
 use tracing::info;
-use tracing_subscriber::{EnvFilter};
+use tracing_subscriber::EnvFilter;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {