feat(serverless): add stdout & axiom logging (#162)

* feat(serverless): add stdout & axiom logging

* chore: add changeset

.changeset/weak-readers-tap.md

@@ -0,0 +1,5 @@
+---
+'@lagon/serverless': patch
+---
+
+Add stdout & axiom logging

packages/serverless/.env.example

@@ -12,3 +12,6 @@ S3_REGION=
 S3_BUCKET=
 S3_ACCESS_KEY_ID=
 S3_SECRET_ACCESS_KEY=
+
+AXIOM_ORG_ID=
+AXIOM_TOKEN=

packages/serverless/Cargo.toml

@@ -14,4 +14,7 @@ rust-s3 = "0.32"
 redis = "0.21.6"
 serde_json = "1.0"
 metrics = "0.20.1"
-metrics-exporter-prometheus = { version = "0.11.0", features = ["http-listener"] }
+metrics-exporter-prometheus = { version = "0.11.0", features = ["http-listener"] }
+log = { version = "0.4.17", features = ["std"] }
+axiom-rs = "0.5.0"
+chrono = "0.4.22"

packages/serverless/src/deployments/filesystem.rs

@@ -2,13 +2,16 @@ use std::io::Write;
 use std::path::PathBuf;
 use std::{env, fs, io, path::Path};
 
+use log::info;
+
 use super::Deployment;
 
 pub fn create_deployments_folder() -> io::Result<()> {
     let path = Path::new("deployments");
 
     if !path.exists() {
         fs::create_dir(path)?;
+        info!("Created deployments folder");
     }
 
     Ok(())
@@ -29,35 +32,40 @@ pub fn get_deployment_code(deployment: &Deployment) -> io::Result<String> {
     Ok(code)
 }
 
-pub fn write_deployment(deployment_id: String, buf: &[u8]) -> io::Result<()> {
-    let mut file = fs::File::create(Path::new("deployments").join(deployment_id + ".js"))?;
+pub fn write_deployment(deployment_id: &str, buf: &[u8]) -> io::Result<()> {
+    let mut file =
+        fs::File::create(Path::new("deployments").join(deployment_id.to_owned() + ".js"))?;
 
     file.write_all(buf)?;
+    info!("Wrote deployment: {}", deployment_id);
 
     Ok(())
 }
 
-pub fn write_deployment_asset(deployment_id: String, asset: &str, buf: &[u8]) -> io::Result<()> {
+pub fn write_deployment_asset(deployment_id: &str, asset: &str, buf: &[u8]) -> io::Result<()> {
     let asset = asset.replace("public/", "");
     let asset = asset.as_str();
 
     let dir = PathBuf::from("deployments")
-        .join(&deployment_id)
+        .join(deployment_id)
         .join(PathBuf::from(asset).parent().unwrap());
     fs::create_dir_all(dir)?;
 
-    let mut file = fs::File::create(Path::new("deployments").join(deployment_id + "/" + asset))?;
+    let mut file =
+        fs::File::create(Path::new("deployments").join(deployment_id.to_owned() + "/" + asset))?;
 
     file.write_all(buf)?;
+    info!("Wrote deployment ({}) asset: {}", deployment_id, asset);
 
     Ok(())
 }
 
-pub fn rm_deployment(deployment_id: String) -> io::Result<()> {
-    fs::remove_file(Path::new("deployments").join(deployment_id.clone() + ".js"))?;
+pub fn rm_deployment(deployment_id: &str) -> io::Result<()> {
+    fs::remove_file(Path::new("deployments").join(deployment_id.to_owned() + ".js"))?;
 
-    // It's possible that folder doesn't exists
-    fs::remove_dir(Path::new("deployments").join(deployment_id)).unwrap_or(());
+    // It's possible that the folder doesn't exists if the deployment has no assets
+    fs::remove_dir(Path::new("deployments").join(deployment_id.clone())).unwrap_or(());
+    info!("Deleted deployment: {}", deployment_id);
 
     Ok(())
 }

packages/serverless/src/deployments/mod.rs

@@ -5,6 +5,7 @@ use std::{
     sync::Arc,
 };
 
+use log::{error, info};
 use mysql::{prelude::Queryable, PooledConn};
 use s3::Bucket;
 use tokio::sync::RwLock;
@@ -100,14 +101,16 @@ pub async fn get_deployments(
     )
     .unwrap();
 
-    let deployments_list = deployments_list.values().cloned().collect();
+    let deployments_list: Vec<Deployment> = deployments_list.values().cloned().collect();
+
+    info!("Found {} deployment(s) to deploy", deployments_list.len());
 
     if let Err(error) = create_deployments_folder() {
-        println!("Could not create deployments folder: {}", error);
+        error!("Could not create deployments folder: {}", error);
     }
 
     if let Err(error) = delete_old_deployments(&deployments_list).await {
-        println!("Failed to delete old deployments: {:?}", error);
+        error!("Failed to delete old deployments: {:?}", error);
     }
 
     {
@@ -116,7 +119,10 @@ pub async fn get_deployments(
         for deployment in deployments_list {
             if !has_deployment_code(&deployment) {
                 if let Err(error) = download_deployment(&deployment, &bucket).await {
-                    println!("Failed to download deployment: {:?}", error);
+                    error!(
+                        "Failed to download deployment ({}): {:?}",
+                        deployment.id, error
+                    );
                 }
             }
 
@@ -130,6 +136,7 @@ pub async fn get_deployments(
 }
 
 async fn delete_old_deployments(deployments: &Vec<Deployment>) -> io::Result<()> {
+    info!("Deleting old deployments");
     let local_deployments_files = fs::read_dir(Path::new("deployments"))?;
 
     for local_deployment_file in local_deployments_files {
@@ -150,17 +157,18 @@ async fn delete_old_deployments(deployments: &Vec<Deployment>) -> io::Result<()>
             .iter()
             .any(|deployment| deployment.id == local_deployment_id)
         {
-            rm_deployment(local_deployment_id)?;
+            rm_deployment(&local_deployment_id)?;
         }
     }
+    info!("Old deployments deleted");
 
     Ok(())
 }
 
 pub async fn download_deployment(deployment: &Deployment, bucket: &Bucket) -> io::Result<()> {
     match bucket.get_object(deployment.id.clone() + ".js").await {
         Ok(object) => {
-            write_deployment(deployment.id.clone(), object.bytes())?;
+            write_deployment(&deployment.id, object.bytes())?;
 
             if deployment.assets.len() > 0 {
                 for asset in &deployment.assets {
@@ -173,7 +181,7 @@ pub async fn download_deployment(deployment: &Deployment, bucket: &Bucket) -> io
                     }
 
                     let object = object.unwrap();
-                    write_deployment_asset(deployment.id.clone(), asset, object.bytes())?;
+                    write_deployment_asset(&deployment.id, asset, object.bytes())?;
                 }
             }