Tweak logs, log configuration info

.gitignore

@@ -1,2 +1,3 @@
 /target
 *.vim
+.idea/

src/configuration/config.rs

@@ -16,14 +16,14 @@
 
 use serde_aux::field_attributes::deserialize_number_from_string;
 
-#[derive(serde::Deserialize, Clone)]
+#[derive(serde::Deserialize, serde::Serialize, Clone, Debug)]
 pub struct ApplicationConfig {
     pub short_url_base: url::Url,
     pub long_url_base: url::Url,
     pub default_expire_in_sec: Option<u32>,
 }
 
-#[derive(serde::Deserialize, Clone)]
+#[derive(serde::Deserialize, serde::Serialize, Clone, Debug)]
 pub struct ServerConfig {
     pub host: String,
     #[serde(deserialize_with = "deserialize_number_from_string")]
@@ -32,31 +32,31 @@ pub struct ServerConfig {
     pub aws: Option<AwsConfig>,
 }
 
-#[derive(serde::Deserialize, Clone)]
+#[derive(serde::Deserialize, serde::Serialize, Clone, Debug)]
 pub struct CertificateConfig {
     pub certificate_path: String,
     pub certificate_key_path: String,
 }
 
-#[derive(serde::Deserialize, Clone)]
+#[derive(serde::Deserialize, serde::Serialize, Clone, Debug)]
 pub struct S3Config {
     pub certificate_bucket: String,
     pub certificate_path: String,
     pub certificate_key_path: String,
 }
 
-#[derive(serde::Deserialize, Clone)]
+#[derive(serde::Deserialize, serde::Serialize, Clone, Debug)]
 pub struct AwsConfig {
     pub region: Option<String>,
     pub s3: S3Config,
 }
 
-#[derive(serde::Deserialize, Clone)]
+#[derive(serde::Deserialize, serde::Serialize, Clone, Debug)]
 pub struct RedisConfig {
     pub url: url::Url,
 }
 
-#[derive(serde::Deserialize, Clone)]
+#[derive(serde::Deserialize, serde::Serialize, Clone, Debug)]
 pub struct Config {
     pub server_internal: ServerConfig,
     pub server_external: ServerConfig,

src/configuration/mod.rs

@@ -23,7 +23,7 @@ use ::config as configrs;
 
 use crate::error::prelude::*;
 
-pub fn load_config() -> SResult<config::Config> {
+pub fn load_config() -> SResult<Config> {
     let base_path = std::env::current_dir().expect("Failed to determine the current directory");
     let configuration_directory = base_path.join("config");
 
@@ -63,7 +63,7 @@ pub fn load_config() -> SResult<config::Config> {
         }
     };
 
-    config.try_deserialize::<config::Config>().map_err(|err| {
+    config.try_deserialize::<Config>().map_err(|err| {
         SError::from_msg(
             SErrorType::ParsingError,
             &format!("Failed to deserialize Config, error: {}", err),

src/server/external/mod.rs

@@ -43,10 +43,7 @@ pub async fn build_server_external(config: &mut Config) -> SResult<Server> {
         })?
         .port();
 
-    tracing::info!("Building services");
     let services = web::Data::new(build_services(config).await?);
-
-    tracing::info!("Configuring external server");
     let mut server = HttpServer::new(move || {
         App::new()
             .wrap(TracingLogger::default())
@@ -56,7 +53,7 @@ pub async fn build_server_external(config: &mut Config) -> SResult<Server> {
     });
 
     if let Some(cert_config) = &config.server_external.certs {
-        tracing::info!("TLS enabled");
+        tracing::info!("External server: TLS enabled");
         let rustls_config = load_rustls_config(
             &cert_config.certificate_path,
             &cert_config.certificate_key_path,
@@ -67,5 +64,6 @@ pub async fn build_server_external(config: &mut Config) -> SResult<Server> {
         server = server.listen(listener)?;
     };
 
+    tracing::info!("External server: Starting with config: {:?}", config.server_external);
     Ok(server.run())
 }

src/server/internal/mod.rs

@@ -43,10 +43,7 @@ pub async fn build_server_internal(config: &mut Config) -> SResult<Server> {
         })?
         .port();
 
-    tracing::info!("Building services");
     let services = web::Data::new(build_services(config).await?);
-
-    tracing::info!("Configuring internal server");
     let mut server = HttpServer::new(move || {
         App::new()
             .wrap(TracingLogger::default())
@@ -56,16 +53,17 @@ pub async fn build_server_internal(config: &mut Config) -> SResult<Server> {
     });
 
     if let Some(cert_config) = &config.server_internal.certs {
-        tracing::info!("TLS enabled");
+        tracing::info!("Internal server: TLS enabled");
         let rustls_config = load_rustls_config(
             &cert_config.certificate_path,
             &cert_config.certificate_key_path,
         );
         server = server.listen_rustls(listener, rustls_config)?;
     } else {
-        tracing::info!("TLS disabled");
+        tracing::info!("Internal server: TLS disabled");
         server = server.listen(listener)?;
     };
 
+    tracing::info!("Internal server: Starting with config: {:?}", config.server_internal);
     Ok(server.run())
 }

src/service/mod.rs

@@ -33,6 +33,7 @@ pub async fn build_services(config: &Config) -> SResult<Services> {
     let redis_client = Arc::new(Mutex::new(
         RedisClient::connect(config.redis.url.as_str()).await?,
     ));
+    info!("Building service layer with application config: {}, redis config: {}", json!(config.application), json!(config.redis));
     let service_shorten = ServiceShorten::new(redis_client, config.clone());
     Ok(Services { service_shorten })
 }