feat: with loggers

crates/dagger-sdk/src/client.rs

@@ -3,18 +3,25 @@ use std::sync::Arc;
 
 use base64::engine::general_purpose;
 use base64::Engine;
+use gql_client::ClientConfig;
+
 use dagger_core::config::Config;
 use dagger_core::connect_params::ConnectParams;
 use dagger_core::engine::Engine as DaggerEngine;
-use gql_client::ClientConfig;
 
 use crate::gen::Query;
+use crate::logging::StdLogger;
 use crate::querybuilder::query;
 
 pub type DaggerConn = Arc<Query>;
 
 pub async fn connect() -> eyre::Result<DaggerConn> {
-    let cfg = Config::default();
+    let cfg = Config::new(None, None, None, None, Some(Arc::new(StdLogger::default())));
+
+    connect_opts(cfg).await
+}
+
+pub async fn connect_opts(cfg: Config) -> eyre::Result<DaggerConn> {
     let (conn, proc) = DaggerEngine::new().start(&cfg).await?;
 
     Ok(Arc::new(Query {

crates/dagger-sdk/src/lib.rs

@@ -2,7 +2,9 @@
 
 mod client;
 mod gen;
+pub mod logging;
 mod querybuilder;
 
 pub use client::*;
+pub use dagger_core::config::Config;
 pub use gen::*;

crates/dagger-sdk/src/logging.rs

@@ -0,0 +1,81 @@
+use dagger_core::logger::{DynLogger, Logger};
+use tracing::Level;
+
+pub fn default_logging() -> eyre::Result<()> {
+    tracing_subscriber::fmt().with_max_level(Level::INFO).init();
+    Ok(())
+}
+
+pub struct StdLogger {}
+
+impl Default for StdLogger {
+    fn default() -> Self {
+        Self {}
+    }
+}
+
+impl Logger for StdLogger {
+    fn stdout(&self, output: &str) -> eyre::Result<()> {
+        println!("{}", output);
+
+        Ok(())
+    }
+
+    fn stderr(&self, output: &str) -> eyre::Result<()> {
+        eprintln!("{}", output);
+
+        Ok(())
+    }
+}
+
+pub struct TracingLogger {}
+
+impl Default for TracingLogger {
+    fn default() -> Self {
+        Self {}
+    }
+}
+
+impl Logger for TracingLogger {
+    fn stdout(&self, output: &str) -> eyre::Result<()> {
+        tracing::info!(output = output, "dagger-sdk");
+
+        Ok(())
+    }
+
+    fn stderr(&self, output: &str) -> eyre::Result<()> {
+        tracing::warn!(output = output, "dagger-sdk");
+
+        Ok(())
+    }
+}
+
+pub struct AggregateLogger {
+    pub loggers: Vec<DynLogger>,
+}
+
+impl Default for AggregateLogger {
+    fn default() -> Self {
+        Self {
+            loggers: Vec::new(),
+        }
+    }
+}
+
+impl Logger for AggregateLogger {
+    fn stdout(&self, output: &str) -> eyre::Result<()> {
+        for logger in &self.loggers {
+            logger.stdout(output).unwrap()
+        }
+
+        Ok(())
+    }
+
+    fn stderr(&self, output: &str) -> eyre::Result<()> {
+        for logger in &self.loggers {
+            logger.stderr(output).unwrap()
+        }
+
+        Ok(())
+    }
+}

crates/dagger-sdk/src/querybuilder.rs

@@ -77,9 +77,6 @@ impl Selection {
         let val = serde_json::to_string(&value).unwrap();
         let val = val[1..val.len() - 1].to_string();
 
-        println!("test");
-        println!("{}", val);
-
         match s.args.as_mut() {
             Some(args) => {
                 let _ = args.insert(name.to_string(), val);
@@ -125,8 +122,7 @@ impl Selection {
     {
         let query = self.build()?;
 
-        let qbs = query.as_str();
-        println!("{}", qbs);
+        tracing::trace!(query = query.as_str(), "dagger-query");
 
         let resp: Option<serde_json::Value> = match gql_client.query(&query).await {
             Ok(r) => r,