initial matching

logging-extractor/src/bake.rs

@@ -0,0 +1,73 @@
+use databake::Bake;
+use std::borrow::Cow;
+
+#[derive(Debug, Default, PartialEq, Clone, Copy, Bake)]
+#[databake(path = crate)]
+pub enum LogLevel {
+    Debug,
+    Info,
+    Notice,
+    Warn,
+    Error,
+    Alert,
+    Critical,
+    Emergency,
+    Exception,
+    #[default]
+    Unknown,
+}
+
+impl From<crate::LogLevel> for LogLevel {
+    fn from(value: crate::LogLevel) -> Self {
+        match value {
+            crate::LogLevel::Debug => LogLevel::Debug,
+            crate::LogLevel::Info => LogLevel::Info,
+            crate::LogLevel::Notice => LogLevel::Notice,
+            crate::LogLevel::Warn => LogLevel::Warn,
+            crate::LogLevel::Error => LogLevel::Error,
+            crate::LogLevel::Alert => LogLevel::Alert,
+            crate::LogLevel::Critical => LogLevel::Critical,
+            crate::LogLevel::Emergency => LogLevel::Emergency,
+            crate::LogLevel::Exception => LogLevel::Exception,
+            crate::LogLevel::Unknown => LogLevel::Unknown,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Bake)]
+#[databake(path = crate)]
+pub struct LoggingStatement<'a> {
+    pub level: LogLevel,
+    pub path: &'a str,
+    pub line: usize,
+    pub message_parts: &'a [&'a str],
+}
+
+pub fn bake_statement(output: &mut String, statement: &crate::LoggingStatement) {
+    let message_parts: Vec<_> = statement.message_parts.iter().map(Cow::as_ref).collect();
+    let statement = LoggingStatement {
+        level: statement.level.into(),
+        path: statement.path,
+        line: statement.line,
+        message_parts: &message_parts,
+    };
+    output.push_str(&statement.bake(&Default::default()).to_string());
+}
+
+#[cfg(feature = "bake")]
+mod bake_test {
+    #[test]
+    fn test_bake() {
+        use databake::test_bake;
+        test_bake!(
+            crate::LoggingStatement,
+            const: crate::LoggingStatement {
+                level: crate::LogLevel::Debug,
+                path: "foo",
+                line: 12usize,
+                message_parts: &["part1", "part2"]
+            },
+            cloud_log_analyser,
+        );
+    }
+}

logging-extractor/src/level.rs

@@ -1,7 +1,8 @@
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 
-#[derive(Debug, Default, PartialEq)]
+#[derive(Debug, Default, PartialEq, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
 pub enum LogLevel {
     Debug,
     Info,
@@ -49,27 +50,8 @@ impl LogLevel {
     }
 }
 
-impl Serialize for LogLevel {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.as_str().serialize(serializer)
-    }
-}
-
 impl Display for LogLevel {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.as_str().fmt(f)
     }
 }
-
-impl<'de> Deserialize<'de> for LogLevel {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = <&str>::deserialize(deserializer)?;
-        Ok(LogLevel::parse(s).unwrap_or_default())
-    }
-}

logging-extractor/src/lib.rs

@@ -7,11 +7,13 @@ use std::io::{Read, Write};
 use tracing::error;
 use walkdir::WalkDir;
 
+mod bake;
 pub mod error;
 pub mod extractor;
 mod level;
 pub mod string;
 
+use crate::bake::bake_statement;
 pub use level::LogLevel;
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -22,13 +24,23 @@ pub struct LoggingStatement<'a> {
     message_parts: Vec<Cow<'a, str>>,
 }
 
-pub fn extract_dir<W: Write>(root: &str, mut output: W) -> Result<(), Error> {
+pub fn extract_dir<W: Write>(root: &str, mut output: W, bake: bool) -> Result<(), Error> {
     let mut code_buff = String::with_capacity(32 * 1024 * 1024);
 
-    writeln!(&mut output, "[").ok();
+    if bake {
+        writeln!(
+            &mut output,
+            "pub const STATEMENTS: &[crate::LoggingStatement] = &[\n"
+        )
+        .ok();
+    } else {
+        writeln!(&mut output, "[").ok();
+    }
 
     let mut first_line = true;
 
+    let mut bake_buff = String::with_capacity(1024 * 1024);
+
     let extractor = LogExtractor::new();
 
     for file in WalkDir::new(root).into_iter().flatten() {
@@ -57,13 +69,23 @@ pub fn extract_dir<W: Write>(root: &str, mut output: W) -> Result<(), Error> {
                     }
                     first_line = false;
                     write!(&mut output, "\t").ok();
-                    let _ = serde_json::to_writer(&mut output, &log_item);
+                    if bake {
+                        bake_buff.clear();
+                        bake_statement(&mut bake_buff, &log_item);
+                        writeln!(&mut output, "{bake_buff}").ok();
+                    } else {
+                        let _ = serde_json::to_writer(&mut output, &log_item);
+                    }
                 }
             }
         }
     }
 
-    writeln!(&mut output, "\n]").ok();
+    if bake {
+        writeln!(&mut output, "];\n").ok();
+    } else {
+        writeln!(&mut output, "\n]").ok();
+    }
 
     Ok(())
 }

logging-extractor/src/main.rs

@@ -6,6 +6,7 @@ use std::io::stdout;
 
 fn main() -> Result<(), Error> {
     let root = args().nth(1).expect("no root provided");
+    let mode = args().nth(2).unwrap_or_else(|| "json".into());
     let root = canonicalize(&root).map_err(|err| Error::RealPath {
         path: root.into(),
         err,
@@ -14,5 +15,5 @@ fn main() -> Result<(), Error> {
 
     let stdout = stdout();
 
-    extract_dir(root, stdout)
+    extract_dir(root, stdout, mode == "rust")
 }