Merge pull request #83 from CleverCloud/devel/fdubois/chore/deps

Update dependencies and use tracing crate instead of slog

Author: FlorentinDUBOIS

Cargo.lock

@@ -16,23 +16,23 @@ keywords = ["kubernetes", "operator", "clevercloud", "openshift"]
 async-trait = "^0.1.53"
 chrono = "^0.4.19"
 clap = { version = "^3.1.18", features = ["derive"] }
-clevercloud-sdk = { version = "^0.10.1", features = ["jsonschemas"] }
+clevercloud-sdk = { version = "^0.10.2", features = ["jsonschemas"] }
 config = "^0.13.1"
 futures = "^0.3.21"
 hostname = "^0.3.1"
 hyper = { version = "^0.14.18", features = ["server", "tcp", "http1"] }
 json-patch = "^0.2.6"
-kube = { version = "^0.72.0", default-features = false, features = [
+kube = { version = "^0.73.0", default-features = false, features = [
     "client",
     "rustls-tls",
     "ws",
     "gzip",
     "derive",
     "jsonpatch",
 ] }
-kube-derive = "^0.72.0"
-kube-runtime = "^0.72.0"
-k8s-openapi = { version = "^0.14.0", default-features = false, features = [
+kube-derive = "^0.73.0"
+kube-runtime = "^0.73.0"
+k8s-openapi = { version = "^0.15.0", default-features = false, features = [
     "v1_21",
 ] }
 lazy_static = { version = "^1.4.0", optional = true }
@@ -44,52 +44,41 @@ opentelemetry-jaeger = { version = "^0.16.0", features = [
     "collector_client",
 ], optional = true }
 paw = "^1.0.0"
-prometheus = { version = "^0.13.0", optional = true }
+prometheus = { version = "^0.13.1", optional = true }
 schemars = { version = "^0.8.10", features = [
     "chrono",
     "indexmap1",
     "uuid1",
     "bytes",
     "url",
 ] }
-sentry = { version = "^0.25.0", optional = true }
+sentry = { version = "^0.26.0", optional = true }
 serde = { version = "^1.0.137", features = ["derive"] }
 serde_json = { version = "^1.0.81", features = [
     "preserve_order",
     "float_roundtrip",
 ] }
 serde_yaml = "^0.8.24"
-slog = { version = "^2.7.0" }
-slog-async = "^2.7.0"
-slog-term = "^2.9.0"
-slog-scope = "^4.4.0"
-slog-stdlog = { version = "^4.1.1", optional = true }
 thiserror = "^1.0.31"
 tokio = { version = "^1.18.2", features = ["full"] }
-tracing = { version = "^0.1.34", optional = true }
-tracing-subscriber = { version = "^0.3.11", optional = true }
+tracing = "^0.1.34"
+tracing-subscriber = { version = "^0.3.11", default-features = false, features = ["std", "ansi", "tracing-log"] }
 tracing-opentelemetry = { version = "^0.17.2", optional = true }
 
 [features]
 default = [
     "metrics",
     "trace",
     "tracker",
-    "slog/release_max_level_debug",
-    "slog/max_level_trace",
 ]
 logging = [
     "clevercloud-sdk/logging",
-    "tracing-subscriber/tracing-log",
-    "slog-stdlog",
 ]
 metrics = ["clevercloud-sdk/metrics", "lazy_static", "prometheus"]
 tracker = ["sentry"]
 trace = [
     "clevercloud-sdk/trace",
     "clevercloud-sdk/tokio",
-    "tracing",
-    "tracing-subscriber",
     "tracing-opentelemetry",
     "opentelemetry",
     "opentelemetry-jaeger",

Cargo.toml

@@ -1,5 +1,6 @@
 # ------------------------------------------------------------------------------
 # Define variables
+PWD					?= $(shell pwd)
 DIST				?= $(PWD)/target/release
 BIN_DIR				?= $(HOME)/.local/bin
 

Makefile

@@ -18,7 +18,7 @@ use hyper::{
     Server,
 };
 use paw::ParseArgs;
-use slog_scope::{crit, error, info};
+use tracing::{error, info};
 
 use crate::{
     cmd::crd::CustomResourceDefinitionError,
@@ -51,6 +51,14 @@ pub enum Error {
     Execution(String, Arc<Error>),
     #[error("failed to execute command, {0}")]
     CustomResourceDefinition(CustomResourceDefinitionError),
+    #[error("failed to parse listen address '{0}', {1}")]
+    Listen(String, AddrParseError),
+    #[error("failed to handle termintion signal, {0}")]
+    SigTerm(io::Error),
+    #[error("failed to create kubernetes client, {0}")]
+    Client(client::Error),
+    #[error("failed to create clever cloud client, {0}")]
+    CleverClient(clevercloud_sdk::oauth10a::proxy::Error),
 }
 
 // -----------------------------------------------------------------------------
@@ -111,35 +119,15 @@ impl ParseArgs for Args {
     }
 }
 
-// -----------------------------------------------------------------------------
-// DaemonError enum
-
-#[derive(thiserror::Error, Debug)]
-pub enum DaemonError {
-    #[error("failed to parse listen address '{0}', {1}")]
-    Listen(String, AddrParseError),
-    #[error("failed to handle termintion signal, {0}")]
-    SigTerm(io::Error),
-    #[error("failed to create kubernetes client, {0}")]
-    Client(client::Error),
-    #[error("failed to create clever cloud client, {0}")]
-    CleverClient(clevercloud_sdk::oauth10a::proxy::Error),
-}
-
 // -----------------------------------------------------------------------------
 // daemon function
 
 #[cfg_attr(feature = "trace", tracing::instrument)]
-pub async fn daemon(
-    kubeconfig: Option<PathBuf>,
-    config: Arc<Configuration>,
-) -> Result<(), DaemonError> {
+pub async fn daemon(kubeconfig: Option<PathBuf>, config: Arc<Configuration>) -> Result<(), Error> {
     // -------------------------------------------------------------------------
     // Create a new kubernetes client from path if defined, or via the
     // environment or defaults locations
-    let kube_client = client::try_new(kubeconfig)
-        .await
-        .map_err(DaemonError::Client)?;
+    let kube_client = client::try_new(kubeconfig).await.map_err(Error::Client)?;
 
     // -------------------------------------------------------------------------
     // Create a new clever-cloud client
@@ -155,14 +143,14 @@ pub async fn daemon(
                 }),
                 proxy.no.to_owned(),
             )
-            .map_err(DaemonError::CleverClient)?;
+            .map_err(Error::CleverClient)?;
 
             ProxyConnectorBuilder::default()
                 .with_proxy(proxy)
                 .build(HttpsConnector::new())
-                .map_err(DaemonError::CleverClient)?
+                .map_err(Error::CleverClient)?
         }
-        _ => ProxyConnectorBuilder::try_from_env().map_err(DaemonError::CleverClient)?,
+        _ => ProxyConnectorBuilder::try_from_env().map_err(Error::CleverClient)?,
     };
 
     let clever_client = Client::builder()
@@ -187,7 +175,10 @@ pub async fn daemon(
 
             info!("Start to listen for events of postgresql addon custom resource");
             if let Err(err) = reconciler.watch(postgresql_state).await {
-                crit!("Could not reconcile postgresql addon custom resource"; "error" => err.to_string());
+                error!(
+                    "Could not reconcile postgresql addon custom resource, {}",
+                    err
+                );
             }
 
             abort();
@@ -197,7 +188,7 @@ pub async fn daemon(
 
             info!("Start to listen for events of redis addon custom resource");
             if let Err(err) = reconciler.watch(redis_state).await {
-                crit!("Could not reconcile redis addon custom resource"; "error" => err.to_string());
+                error!("Could not reconcile redis addon custom resource, {}", err);
             }
 
             abort();
@@ -207,7 +198,7 @@ pub async fn daemon(
 
             info!("Start to listen for events of mysql addon custom resource");
             if let Err(err) = reconciler.watch(mysql_state).await {
-                crit!("Could not reconcile mysql addon custom resource"; "error" => err.to_string());
+                error!("Could not reconcile mysql addon custom resource, {}", err);
             }
 
             abort();
@@ -217,7 +208,7 @@ pub async fn daemon(
 
             info!("Start to listen for events of mongodb addon custom resource");
             if let Err(err) = reconciler.watch(mongodb_state).await {
-                crit!("Could not reconcile mongodb addon custom resource"; "error" => err.to_string());
+                error!("Could not reconcile mongodb addon custom resource, {}", err);
             }
 
             abort();
@@ -227,7 +218,7 @@ pub async fn daemon(
 
             info!("Start to listen for events of pulsar addon custom resource");
             if let Err(err) = reconciler.watch(pulsar_state).await {
-                crit!("Could not reconcile plusar addon custom resource"; "error" => err.to_string());
+                error!("Could not reconcile plusar addon custom resource, {}", err);
             }
 
             abort();
@@ -237,7 +228,10 @@ pub async fn daemon(
 
             info!("Start to listen for events of config-provider addon custom resource");
             if let Err(err) = reconciler.watch(config_provider_state).await {
-                crit!("Could not reconcile config-provider addon custom resource"; "error" => err.to_string());
+                error!(
+                    "Could not reconcile config-provider addon custom resource, {}",
+                    err
+                );
             }
 
             abort();
@@ -247,7 +241,10 @@ pub async fn daemon(
 
             info!("Start to listen for events of elasticsearch addon custom resource");
             if let Err(err) = reconciler.watch(elasticsearch_state).await {
-                crit!("Could not reconcile elasticsearch addon custom resource"; "error" => err.to_string());
+                error!(
+                    "Could not reconcile elasticsearch addon custom resource, {}",
+                    err
+                );
             }
 
             abort();
@@ -260,13 +257,13 @@ pub async fn daemon(
         .operator
         .listen
         .parse()
-        .map_err(|err| DaemonError::Listen(config.operator.listen.to_owned(), err))?;
+        .map_err(|err| Error::Listen(config.operator.listen.to_owned(), err))?;
 
     let server = tokio::spawn(async move {
         let builder = match Server::try_bind(&addr) {
             Ok(builder) => builder,
             Err(err) => {
-                crit!("Could not bind http server"; "error" => err.to_string());
+                error!("Could not bind http server, {}", err);
                 abort();
             }
         };
@@ -277,17 +274,15 @@ pub async fn daemon(
 
         info!("Start to listen for http request on {}", addr);
         if let Err(err) = server.await {
-            crit!("Could not serve http server"; "error" => err.to_string());
+            error!("Could not serve http server, {}", err);
         }
 
         abort()
     });
 
     // -------------------------------------------------------------------------
     // Wait for termination signal
-    tokio::signal::ctrl_c()
-        .await
-        .map_err(DaemonError::SigTerm)?;
+    tokio::signal::ctrl_c().await.map_err(Error::SigTerm)?;
 
     // -------------------------------------------------------------------------
     // Cancel reconcilers
@@ -296,7 +291,7 @@ pub async fn daemon(
     for handle in handles {
         if let Err(err) = handle.await {
             if !err.is_cancelled() {
-                error!("Could not wait for the task to complete"; "error" => err.to_string());
+                error!("Could not wait for the task to complete, {}", err);
             }
         }
     }
@@ -306,7 +301,10 @@ pub async fn daemon(
     server.abort();
     if let Err(err) = server.await {
         if !err.is_cancelled() {
-            error!("Could not wait for the http server to gracefully close"; "error" => err.to_string());
+            error!(
+                "Could not wait for the http server to gracefully close, {}",
+                err
+            );
         }
     }
 

src/cmd/mod.rs

@@ -0,0 +1,40 @@
+//! # Logging module
+//!
+//! This module provides logging facilities and helpers
+
+use tracing::Level;
+
+// -----------------------------------------------------------------------------
+// Error enumeration
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error("failed to set global default subscriber, {0}")]
+    GlobalDefaultSubscriber(tracing::subscriber::SetGlobalDefaultError),
+}
+
+// -----------------------------------------------------------------------------
+// helpers
+
+pub const fn level(verbosity: usize) -> Level {
+    match verbosity {
+        0 => Level::ERROR,
+        1 => Level::WARN,
+        2 => Level::INFO,
+        3 => Level::DEBUG,
+        _ => Level::TRACE,
+    }
+}
+
+pub fn initialize(verbosity: usize) -> Result<(), Error> {
+    tracing::subscriber::set_global_default(
+        tracing_subscriber::fmt()
+            .with_max_level(level(verbosity))
+            .with_thread_names(true)
+            .with_line_number(true)
+            .with_thread_ids(true)
+            .with_target(true)
+            .finish(),
+    )
+    .map_err(Error::GlobalDefaultSubscriber)
+}