Merge branch 'main' into evalir/new-pecorino-timestamp

Author: Evalir

Cargo.toml

@@ -4,7 +4,7 @@ name = "init4-bin-base"
 description = "Internal utilities for binaries produced by the init4 team"
 keywords = ["init4", "bin", "base"]
 
-version = "0.9.0"
+version = "0.12.0"
 edition = "2021"
 rust-version = "1.81"
 authors = ["init4", "James Prestwich"]
@@ -16,8 +16,11 @@ repository = "https://github.com/init4tech/bin-base"
 init4-from-env-derive =  "0.1.0"
 
 # Signet
-signet-constants = { version = "0.8.0" }
-signet-tx-cache = { version = "0.8.0", optional = true }
+signet-constants = { version = "0.10.0" }
+signet-tx-cache = { version = "0.10.0", optional = true }
+
+# alloy
+alloy = { version = "1.0.25", optional = true, default-features = false, features = ["std", "signer-local", "consensus", "network"] }
 
 # Tracing
 tracing = "0.1.40"
@@ -45,7 +48,6 @@ tokio = { version = "1.36.0", optional = true }
 
 # Other
 thiserror = "2.0.11"
-alloy = { version = "1.0.11", optional = true, default-features = false, features = ["std", "signer-aws", "signer-local", "consensus", "network"] }
 serde = { version = "1", features = ["derive"] }
 async-trait = { version = "0.1.80", optional = true }
 eyre = { version = "0.6.12", optional = true }
@@ -56,6 +58,7 @@ tower = { version = "0.5.2", optional = true }
 aws-config = { version = "1.1.7", optional = true }
 aws-sdk-kms = { version = "1.15.0", optional = true }
 reqwest = { version = "0.12.15", optional = true }
+rustls = { version = "0.23.31", optional = true }
 
 [dev-dependencies]
 ajj = "0.3.1"
@@ -66,9 +69,11 @@ signal-hook = "0.3.17"
 tokio = { version = "1.43.0", features = ["macros"] }
 
 [features]
-default = ["alloy"]
-alloy = ["dep:alloy", "dep:async-trait", "dep:aws-config", "dep:aws-sdk-kms"]
+default = ["alloy", "rustls"]
+alloy = ["dep:alloy"]
+aws = ["alloy", "alloy?/signer-aws", "dep:async-trait", "dep:aws-config", "dep:aws-sdk-kms"]
 perms = ["dep:oauth2", "dep:tokio", "dep:reqwest", "dep:signet-tx-cache", "dep:eyre", "dep:axum", "dep:tower"]
+rustls = ["dep:rustls", "rustls/aws-lc-rs"]
 
 [[example]]
 name = "oauth"
@@ -79,3 +84,13 @@ required-features = ["perms"]
 name = "tx_cache"
 path = "examples/tx_cache.rs"
 required-features = ["perms"]
+
+
+# [patch.crates-io]
+# signet-bundle = { path = "../sdk/crates/bundle"}
+# signet-constants = { path = "../sdk/crates/constants"}
+# signet-evm = { path = "../sdk/crates/evm"}
+# signet-extract = { path = "../sdk/crates/extract"}
+# signet-tx-cache = { path = "../sdk/crates/tx-cache"}
+# signet-types = { path = "../sdk/crates/types"}
+# signet-zenith = { path = "../sdk/crates/zenith"}

from-env-derive/Cargo.toml

@@ -2,7 +2,7 @@
 name = "init4-from-env-derive"
 
 description = "A derive macro for `init4_bin_base::FromEnv`"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 rust-version = "1.81"
 authors = ["init4", "James Prestwich"]
@@ -20,4 +20,4 @@ syn = { version = "2.0.100", features = ["full", "parsing"] }
 proc-macro = true
 
 [dev-dependencies]
-init4-bin-base = "0.3"
+init4-bin-base = "0.9"

from-env-derive/src/field.rs

@@ -114,7 +114,7 @@ impl Field {
             return field_name.clone();
         }
 
-        let n = format!("field_{}", idx);
+        let n = format!("field_{idx}");
         syn::parse_str::<Ident>(&n)
             .map_err(|_| syn::Error::new(self.span, "Failed to create field name"))
             .unwrap()
@@ -199,7 +199,7 @@ impl Field {
         })
     }
 
-    pub(crate) fn expand_item_from_env(&self, err_ident: &Ident, idx: usize) -> TokenStream {
+    pub(crate) fn expand_item_from_env(&self, err_ident: &syn::Path, idx: usize) -> TokenStream {
         // Produces code fo the following form:
         // ```rust
         // // EITHER

from-env-derive/src/lib.rs

@@ -102,15 +102,23 @@ impl Input {
         }
     }
 
-    fn error_ident(&self) -> syn::Ident {
+    fn error_ident(&self) -> syn::Path {
+        if self.is_infallible() {
+            return syn::parse_str("::std::convert::Infallible").unwrap();
+        }
+
         let error_name = format!("{}EnvError", self.ident);
-        syn::parse_str::<syn::Ident>(&error_name)
+        syn::parse_str::<syn::Path>(&error_name)
             .map_err(|_| {
                 syn::Error::new(self.ident.span(), "Failed to parse error ident").to_compile_error()
             })
             .unwrap()
     }
 
+    fn is_infallible(&self) -> bool {
+        self.error_variants().is_empty()
+    }
+
     fn error_variants(&self) -> Vec<TokenStream> {
         self.fields
             .iter()
@@ -152,6 +160,10 @@ impl Input {
         let error_variant_displays = self.error_variant_displays();
         let error_variant_sources = self.expand_variant_sources();
 
+        if error_variants.is_empty() {
+            return Default::default();
+        }
+
         quote! {
             #[doc = "Generated error type for [`FromEnv`] for"]
             #[doc = #struct_name_str]
@@ -195,6 +207,7 @@ impl Input {
     fn expand_impl(&self) -> TokenStream {
         let env_item_info = self.env_item_info();
         let struct_name = &self.ident;
+
         let error_ident = self.error_ident();
 
         let item_from_envs = self.item_from_envs();
@@ -226,16 +239,25 @@ impl Input {
 
     fn expand_mod(&self) -> TokenStream {
         // let expanded_impl = expand_impl(input);
-        let expanded_error = self.expand_error();
         let expanded_impl = self.expand_impl();
         let crate_name = &self.crate_name;
-        let error_ident = self.error_ident();
 
         let mod_ident =
             syn::parse_str::<syn::Ident>(&format!("__from_env_impls_{}", self.ident)).unwrap();
 
+        let expanded_error = self.expand_error();
+
+        let use_err = if !expanded_error.is_empty() {
+            let error_ident = self.error_ident();
+            quote! {
+                pub use #mod_ident::#error_ident;
+            }
+        } else {
+            quote! {}
+        };
+
         quote! {
-            pub use #mod_ident::#error_ident;
+            #use_err
             mod #mod_ident {
                 use super::*;
                 use #crate_name::utils::from_env::{FromEnv, FromEnvErr, FromEnvVar, EnvItemInfo};

from-env-derive/tests/macro.rs

@@ -1,5 +1,16 @@
 use init4_from_env_derive::FromEnv;
 
+// Compile check for a struct with no fallible fields (and therefore no
+// associated env error).
+#[derive(Debug, FromEnv)]
+pub struct InfallibleConfig {
+    #[from_env(var = "INTERNAL", desc = "An infallible string", infallible)]
+    pub internal: String,
+
+    #[from_env(var = "INTERNAL_COW", desc = "An infallible Cow<str>", infallible)]
+    pub internal_cow: std::borrow::Cow<'static, str>,
+}
+
 #[derive(FromEnv, Debug)]
 pub struct FromEnvTest {
     /// This is a guy named tony
@@ -81,10 +92,10 @@ mod test {
     }
 
     fn assert_contains(vec: &Vec<&'static EnvItemInfo>, item: &EnvItemInfo) {
-        let item = vec.iter().find(|i| i.var == item.var).unwrap();
-        assert_eq!(item.var, item.var);
-        assert_eq!(item.description, item.description);
-        assert_eq!(item.optional, item.optional);
+        let i = vec.iter().find(|i| i.var == item.var).unwrap();
+        assert_eq!(i.var, item.var);
+        assert_eq!(i.description, item.description);
+        assert_eq!(i.optional, item.optional);
     }
 
     #[test]

src/lib.rs

@@ -35,6 +35,10 @@ pub mod utils {
     pub mod otlp;
 
     #[cfg(feature = "alloy")]
+    /// Alloy Provider configuration and instantiation
+    pub mod provider;
+
+    #[cfg(feature = "aws")]
     /// Signer using a local private key or AWS KMS key.
     pub mod signer;
 
@@ -77,5 +81,11 @@ pub mod deps {
 pub fn init4() -> Option<utils::otlp::OtelGuard> {
     let guard = utils::tracing::init_tracing();
     utils::metrics::init_metrics();
+
+    // This will install the AWS-LC-Rust TLS provider for rustls, if no other
+    // provider has been installed yet
+    #[cfg(feature = "rustls")]
+    let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
+
     guard
 }

src/utils/from_env.rs

@@ -3,6 +3,7 @@ use signet_constants::{
     SignetSystemConstants,
 };
 use std::{convert::Infallible, env::VarError, num::ParseIntError, str::FromStr};
+use tracing_core::metadata::ParseLevelError;
 
 /// The `derive(FromEnv)` macro.
 ///
@@ -278,7 +279,7 @@ pub fn parse_env_if_present<T: FromStr>(env_var: &str) -> Result<T, FromEnvErr<T
 ///
 pub trait FromEnv: core::fmt::Debug + Sized + 'static {
     /// Error type produced when loading from the environment.
-    type Error: core::error::Error + Clone;
+    type Error: core::error::Error + Clone + PartialEq + Eq;
 
     /// Get the required environment variable names for this type.
     ///
@@ -453,7 +454,7 @@ where
 /// ```
 pub trait FromEnvVar: core::fmt::Debug + Sized + 'static {
     /// Error type produced when parsing the primitive.
-    type Error: core::error::Error;
+    type Error: core::error::Error + Clone + PartialEq + Eq;
 
     /// Load the primitive from the environment at the given variable.
     fn from_env_var(env_var: &str) -> Result<Self, FromEnvErr<Self::Error>>;
@@ -613,7 +614,6 @@ impl_for_parseable!(
     i128,
     isize,
     url::Url,
-    tracing::Level,
     SignetConstants,
     SignetEnvironmentConstants,
     SignetSystemConstants,
@@ -646,6 +646,28 @@ impl FromEnvVar for bool {
     }
 }
 
+/// Error type for parsing tracing levels from the environment.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
+#[error("failed to parse tracing level from environment variable")]
+pub struct LevelParseError;
+
+impl From<ParseLevelError> for LevelParseError {
+    fn from(_: ParseLevelError) -> Self {
+        LevelParseError
+    }
+}
+
+impl FromEnvVar for tracing::Level {
+    type Error = LevelParseError;
+
+    fn from_env_var(env_var: &str) -> Result<Self, FromEnvErr<Self::Error>> {
+        let s: String = std::env::var(env_var).map_err(|e| FromEnvErr::env_err(env_var, e))?;
+        s.parse()
+            .map_err(Into::into)
+            .map_err(FromEnvErr::parse_error)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::{borrow::Cow, time::Duration};