we got logging

Author: juleswritescode

.gitignore

@@ -17,3 +17,5 @@ target/
 # File system
 .DS_Store
 desktop.ini
+
+*.log

Cargo.lock

@@ -35,6 +35,8 @@ pg_diagnostics.workspace = true
 tokio = { version = "1.40.0", features = ["io-std", "macros", "rt-multi-thread", "sync", "time"] }
 tokio-util = "0.7.12"
 tower-lsp = "0.20.0"
+tracing = "0.1.40"
+tracing-subscriber = "0.3.18"
 
 [dev-dependencies]
 

crates/pg_lsp/Cargo.toml

@@ -1,6 +1,9 @@
+use std::sync::Arc;
+
 use pg_schema_cache::SchemaCache;
+use pg_workspace::Workspace;
 use sqlx::{postgres::PgListener, PgPool};
-use tokio::task::JoinHandle;
+use tokio::{sync::RwLock, task::JoinHandle};
 
 pub(crate) struct DbConnection {
     pool: PgPool,
@@ -10,13 +13,10 @@ pub(crate) struct DbConnection {
 }
 
 impl DbConnection {
-    pub(crate) async fn new<F>(
+    pub(crate) async fn new(
         connection_string: String,
-        on_schema_update: F,
-    ) -> Result<Self, sqlx::Error>
-    where
-        F: Fn(SchemaCache) -> () + Send + 'static,
-    {
+        ide: Arc<RwLock<Workspace>>,
+    ) -> Result<Self, sqlx::Error> {
         let pool = PgPool::connect(&connection_string).await?;
 
         let mut listener = PgListener::connect_with(&pool).await?;
@@ -36,7 +36,7 @@ impl DbConnection {
                             Ok(not) => {
                                 if not.payload().to_string() == "reload schema" {
                                     let schema_cache = SchemaCache::load(&cloned_pool).await;
-                                    on_schema_update(schema_cache);
+                                    ide.write().await.set_schema_cache(schema_cache);
                                 };
                             }
                             Err(why) => {

crates/pg_lsp/src/db_connection.rs

@@ -61,12 +61,13 @@ impl SimpleTokioDebouncer {
         }
     }
 
+    #[tracing::instrument(name = "Adding task to debouncer", skip(self, block))]
     pub async fn debounce(&self, block: AsyncBlock) {
         if self
             .shutdown_flag
             .load(std::sync::atomic::Ordering::Relaxed)
         {
-            println!(
+            tracing::error!(
                 "Trying to debounce tasks, but the Debouncer is in the process of shutting down."
             );
             return;
@@ -75,6 +76,7 @@ impl SimpleTokioDebouncer {
         self.tx.send(block).await.unwrap();
     }
 
+    #[tracing::instrument(name = "Shutting down debouncer", skip(self))]
     pub async fn shutdown(&self) {
         self.shutdown_flag
             .store(true, std::sync::atomic::Ordering::Relaxed);

crates/pg_lsp/src/debouncer.rs

@@ -1,12 +1,28 @@
+use std::{fs::File, path::PathBuf, str::FromStr, sync::Mutex};
+
 use pg_lsp::server::LspServer;
 use tower_lsp::{LspService, Server};
 
 #[tokio::main]
-async fn main() {
+async fn main() -> anyhow::Result<()> {
+    let path = PathBuf::from_str("pglsp.log").expect("Opened the log file.");
+    let file = File::create(path).expect("Could not open the file.");
+
+    let subscriber = tracing_subscriber::FmtSubscriber::builder()
+        .with_ansi(false)
+        .with_writer(Mutex::new(file))
+        .finish();
+
+    tracing::subscriber::set_global_default(subscriber)?;
+
     let stdin = tokio::io::stdin();
     let stdout = tokio::io::stdout();
 
+    tracing::info!("Starting server.");
+
     let (service, socket) = LspService::new(|client| LspServer::new(client));
 
     Server::new(stdin, stdout, socket).serve(service).await;
+
+    Ok(())
 }