OWEN - configs building rework

owen/src/aws-lambda/main.rs

@@ -70,10 +70,10 @@ async fn function_handler(
         .load()
         .await;
 
-    let owen_config = owen::Config::build();
+    let owen_config = owen::Config::build()?;
 
-    let queue = MessageQueue::build(&aws_main_config);
-    let mut storage = MessageStorage::build(&aws_main_config);
+    let queue = MessageQueue::build(&aws_main_config)?;
+    let mut storage = MessageStorage::build(&aws_main_config)?;
 
     build_input_folder(&queue, &mut storage).await?;
 
@@ -147,16 +147,11 @@ async fn function_handler(
 async fn main() -> Result<(), lambda_runtime::Error> {
     println!("Lambda cold start");
 
-    let region_provider = RegionProviderChain::default_provider().or_else("us-east-1");
-    let aws_main_config = aws_config::defaults(BehaviorVersion::latest())
-        .region(region_provider)
-        .load()
-        .await;
-    set_secret_envs(&aws_main_config)
+    set_secret_envs()
         .await
         .map_err(|err| format!("Setting secret envs failed: {err}"))?;
-    let owen_config = owen::Config::build();
-    let _guard = init_sentry(&owen_config);
+
+    let _guard = init_sentry();
     init_logging()?;
 
     tracing::init_default_subscriber();

owen/src/aws-lambda/message_queue.rs

@@ -21,8 +21,8 @@ impl MessageQueue {
     pub fn get_env_var(key: &str) -> String {
         env::var(key).expect(format!("Missing env variable: {key}").as_str())
     }
-    pub fn build(aws_main_config: &aws_config::SdkConfig) -> Self {
-        Self {
+    pub fn build(aws_main_config: &aws_config::SdkConfig) -> Result<Self> {
+        Ok(Self {
             client: aws_sdk_dynamodb::Client::new(aws_main_config),
             table_name: MessageQueue::get_env_var("MESSAGE_STATUS_TABLE_NAME"),
             index_name: MessageQueue::get_env_var("PROCESSING_STATUS_INDEX_NAME"),
@@ -36,7 +36,7 @@ impl MessageQueue {
             reserved_status_value: MessageQueue::get_env_var("RESERVED_STATUS_VALUE"),
             rejected_status_value: MessageQueue::get_env_var("REJECTED_STATUS_VALUE"),
             owen_instance_name: MessageQueue::get_env_var("USERNAME"),
-        }
+        })
     }
 
     pub async fn reserve_message_folder(&self) -> Result<Option<String>> {

owen/src/aws-lambda/secrets.rs

@@ -1,4 +1,5 @@
 use anyhow::Result;
+use aws_config::{meta::region::RegionProviderChain, BehaviorVersion};
 use serde::{Deserialize, Serialize};
 use std::env;
 
@@ -9,7 +10,12 @@ struct OwenSecretEnvs {
     PRIVATE_KEY: String,
 }
 
-pub async fn set_secret_envs(aws_main_config: &aws_config::SdkConfig) -> Result<()> {
+pub async fn set_secret_envs() -> Result<()> {
+    let region_provider = RegionProviderChain::default_provider().or_else("us-east-1");
+    let aws_main_config = aws_config::defaults(BehaviorVersion::latest())
+        .region(region_provider)
+        .load()
+        .await;
     let client = aws_sdk_secretsmanager::Client::new(&aws_main_config);
     let owen_lambda_secrets_name = env::var("OWEN_LAMBDA_SECRETS_NAME")
         .expect(format!("Missing env variable: OWEN_LAMBDA_SECRETS_NAME").as_str());

owen/src/lib.rs

@@ -65,7 +65,7 @@ impl Config {
         env::var(key).expect(format!("Missing env variable: {key}").as_str())
     }
 
-    pub fn build() -> Config {
+    pub fn build() -> anyhow::Result<Config> {
         if is_local() {
             println!("Running local setup");
             dotenvy::from_filename(".env.local").unwrap();
@@ -152,7 +152,7 @@ impl Config {
             use_batch_sender,
         };
 
-        config
+        Ok(config)
     }
 
     fn try_private_key(&self) -> anyhow::Result<&String> {

owen/src/local-s3/config.rs

@@ -1,6 +1,6 @@
+use anyhow::Result;
 use aws_config::{meta::region::RegionProviderChain, BehaviorVersion, Region, SdkConfig};
 use std::env;
-
 pub struct LocalS3Config {
     pub owen_config: owen::Config,
     pub aws_sdk_config: SdkConfig,
@@ -11,8 +11,8 @@ impl LocalS3Config {
         env::var(key).expect(format!("Missing env variable: {key}").as_str())
     }
 
-    pub async fn build() -> Self {
-        let owen_config = owen::Config::build();
+    pub async fn build() -> Result<Self> {
+        let owen_config = owen::Config::build()?;
         let aws_default_region = LocalS3Config::get_env_var("AWS_DEFAULT_REGION");
 
         let region_provider =
@@ -23,9 +23,9 @@ impl LocalS3Config {
             .load()
             .await;
 
-        Self {
+        Ok(Self {
             owen_config,
             aws_sdk_config,
-        }
+        })
     }
 }

owen/src/local-s3/main.rs

@@ -15,12 +15,12 @@ async fn main() -> Result<()> {
     let LocalS3Config {
         owen_config,
         aws_sdk_config,
-    } = LocalS3Config::build().await;
+    } = LocalS3Config::build().await?;
 
-    let _guard = init_sentry(&owen_config);
+    let _guard = init_sentry();
 
-    let mut storage = owen::s3_message_storage::MessageStorage::build(&aws_sdk_config);
-    let mut database = message_database::MessageDatabase::build();
+    let mut storage = owen::s3_message_storage::MessageStorage::build(&aws_sdk_config)?;
+    let mut database = message_database::MessageDatabase::build()?;
 
     storage.clear_input_folder()?;
     let max_s3_message_folders: Vec<String> = storage

owen/src/local-s3/message_database.rs

@@ -12,7 +12,7 @@ pub struct MessageDatabase {
 }
 
 impl MessageDatabase {
-    pub fn build() -> Self {
+    pub fn build() -> Result<Self> {
         let database_name =
             std::env::var("DATABASE_NAME").unwrap_or_else(|_| DEFAULT_DATABASE_NAME.to_string());
 
@@ -39,10 +39,10 @@ impl MessageDatabase {
             .map_err(|err| format!("Create database table error: {}", err))
             .expect("Create database table: unknown error");
 
-        Self {
+        Ok(Self {
             connection,
             table_name,
-        }
+        })
     }
 
     pub fn save_message_folders(

owen/src/logger.rs

@@ -5,11 +5,19 @@ use sentry::protocol::Attachment;
 use serde_json::json;
 use std::io::Read;
 
-pub fn init_sentry(config: &Config) -> Option<sentry::ClientInitGuard> {
-    if !config.disable_telemetry {
+pub fn init_sentry() -> Option<sentry::ClientInitGuard> {
+    let disable_telemetry: bool = matches!(
+        std::env::var("DISABLE_TELEMETRY")
+            .unwrap_or_else(|_| "false".to_string())
+            .as_str(),
+        "1" | "true"
+    );
+
+    let environment = Config::get_env_var("ENVIRONMENT");
+    if !disable_telemetry {
         let guard: sentry::ClientInitGuard = sentry::init(("https://2cea3d6af1cb8e4bd9c7c39530d390a1@o4508766269014016.ingest.us.sentry.io/4508766275043328",
             sentry::ClientOptions {
-                environment: Some(config.environment.to_owned().into()),
+                environment: Some(environment.to_owned().into()),
                 release: sentry::release_name!(),
                 attach_stacktrace: false,
                 auto_session_tracking: true,

owen/src/main.rs

@@ -6,8 +6,8 @@ use owen::{
 
 fn main() -> Result<()> {
     init_logging()?;
-    let config = Config::build();
-    let _guard = init_sentry(&config);
+    let config = Config::build()?;
+    let _guard = init_sentry();
 
     tokio::runtime::Builder::new_multi_thread()
         .enable_all()

owen/src/s3_message_storage.rs

@@ -21,16 +21,16 @@ impl MessageStorage {
     pub fn get_env_var(key: &str) -> String {
         env::var(key).expect(format!("Missing env variable: {key}").as_str())
     }
-    pub fn build(aws_main_config: &aws_config::SdkConfig) -> Self {
-        Self {
+    pub fn build(aws_main_config: &aws_config::SdkConfig) -> Result<Self> {
+        Ok(Self {
             client: aws_sdk_s3::Client::new(aws_main_config),
             bucket_name: MessageStorage::get_env_var("MESSAGES_BUCKET_NAME"),
             input_files_dir: MessageStorage::get_env_var("INPUT_FILES_DIR"),
             message_bucket_prefix: MessageStorage::get_env_var("MESSAGE_BUCKET_PREFIX"),
             fallback_bucket_name: MessageStorage::get_env_var("FALLBACK_BUCKET_NAME"),
             local_to_s3_folder_mapping: HashMap::new(),
             s3_message_folders: vec![],
-        }
+        })
     }
 
     fn build_local_object_path(