initial matching

logging-extractor/Cargo.lock

@@ -35,6 +35,29 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "databake"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a04fbfbecca8f0679c8c06fef907594adcc3e2052e11163a6d30535a1a5604d"
+dependencies = [
+ "databake-derive",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "databake-derive"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4078275de501a61ceb9e759d37bdd3d7210e654dbc167ac1a3678ef4435ed57b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
 [[package]]
 name = "encode_unicode"
 version = "0.3.6"
@@ -89,6 +112,7 @@ name = "logging-extractor"
 version = "0.1.0"
 dependencies = [
  "cc",
+ "databake",
  "insta",
  "memchr",
  "serde",
@@ -261,6 +285,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "test-case"
 version = "3.3.1"

logging-extractor/Cargo.toml

@@ -19,6 +19,7 @@ walkdir = "2.5.0"
 tree-sitter = "0.22.6"
 tree-sitter-php = "0.22.7"
 memchr = "2.7.4"
+databake = { version = "0.1.8", features = ["derive"] }
 
 [build-dependencies]
 cc = "1.1.6"

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")
 }

logging-extractor/tests/snapshot.rs

@@ -5,7 +5,7 @@ use test_case::test_case;
 fn snapshot_test(name: &str) {
     let root = format!("test-data/{name}");
     let mut output = Vec::<u8>::with_capacity(1024 * 1024);
-    extract_dir(&root, &mut output).unwrap();
+    extract_dir(&root, &mut output, false).unwrap();
     let output: Vec<LoggingStatement> = serde_json::from_slice(&output).unwrap();
 
     insta::assert_json_snapshot!(output)