Generate JSON Schema for both Resolved Telemetry Schema and Resolved Registry

Cargo.toml

@@ -43,14 +43,15 @@ thiserror = "1.0.58"
 ureq = "2.9.7"
 regex = "1.10.3"
 rayon = "1.10.0"
-ordered-float = { version = "4.2.0", features = ["serde"] }
+ordered-float = { version = "4.2.0", features = ["serde", "schemars"] }
 walkdir = "2.5.0"
 anyhow = "1.0.83"
 itertools = "0.12.1"
 globset = { version = "0.4.14", features = ["serde1"] }
 miette = { version = "7.2.0", features = ["fancy", "serde"] }
 include_dir = "0.7.3"
 tempdir = "0.3.7"
+schemars = "0.8.21"
 
 # Features definition =========================================================
 [features]
@@ -83,6 +84,7 @@ walkdir.workspace = true
 include_dir.workspace = true
 thiserror.workspace = true
 miette.workspace = true
+schemars.workspace = true
 
 rayon = "1.10.0"
 

crates/weaver_codegen_test/build.rs

@@ -14,7 +14,7 @@ use weaver_cache::Cache;
 use weaver_common::in_memory::LogMessage;
 use weaver_common::{in_memory, Logger};
 use weaver_forge::file_loader::FileSystemFileLoader;
-use weaver_forge::registry::TemplateRegistry;
+use weaver_forge::registry::ResolvedRegistry;
 use weaver_forge::{OutputDirective, TemplateEngine};
 use weaver_resolver::SchemaResolver;
 use weaver_semconv::path::RegistryPath;
@@ -51,7 +51,7 @@ fn main() {
     let loader = FileSystemFileLoader::try_new(TEMPLATES_PATH.into(), TARGET)
         .unwrap_or_else(|e| process_error(&logger, e));
     let engine = TemplateEngine::try_new(loader).unwrap_or_else(|e| process_error(&logger, e));
-    let template_registry = TemplateRegistry::try_from_resolved_registry(
+    let template_registry = ResolvedRegistry::try_from_resolved_registry(
         schema
             .registry(REGISTRY_ID)
             .expect("Failed to get the registry from the resolved schema"),

crates/weaver_common/src/in_memory.rs

@@ -151,4 +151,9 @@
             .expect("Failed to lock messages")
             .push(LogMessage::Log(message.to_owned()));
     }
+
+    /// Mute all the messages except for the warnings and errors.
+    fn mute(&self) {
+        // We do not mute the logger in this implementation.
+    }
 }

crates/weaver_common/src/lib.rs

@@ -47,6 +47,9 @@
 
     /// Logs a message without icon.
     fn log(&self, message: &str);
+
+    /// Mute all the messages except for the warnings and errors.
+    fn mute(&self);
 }
 
 /// A generic logger that can be used to log messages to the console.
@@ -55,6 +58,7 @@
 pub struct ConsoleLogger {
     logger: Arc<Mutex<paris::Logger<'static>>>,
     debug_level: u8,
+    mute: Arc<Mutex<bool>>,
 }
 
 impl ConsoleLogger {
@@ -64,14 +68,16 @@
         ConsoleLogger {
             logger: Arc::new(Mutex::new(paris::Logger::new())),
             debug_level,
+            mute: Arc::new(Mutex::new(false)),
         }
     }
 }
 
 impl Logger for ConsoleLogger {
     /// Logs an trace message (only with debug enabled).
     fn trace(&self, message: &str) {
-        if self.debug_level > 0 {
+        let mute = *self.mute.lock().expect("Failed to lock mute");
+        if self.debug_level > 0 && !mute {
             _ = self
                 .logger
                 .lock()
@@ -82,6 +88,10 @@
 
     /// Logs an info message.
     fn info(&self, message: &str) {
+        if *self.mute.lock().expect("Failed to lock mute") {
+            return;
+        }
+
         _ = self
             .logger
             .lock()
@@ -109,6 +119,10 @@
 
     /// Logs a success message.
     fn success(&self, message: &str) {
+        if *self.mute.lock().expect("Failed to lock mute") {
+            return;
+        }
+
         _ = self
             .logger
             .lock()
@@ -118,6 +132,10 @@
 
     /// Logs a newline.
     fn newline(&self, count: usize) {
+        if *self.mute.lock().expect("Failed to lock mute") {
+            return;
+        }
+
         _ = self
             .logger
             .lock()
@@ -127,6 +145,10 @@
 
     /// Indents the logger.
     fn indent(&self, count: usize) {
+        if *self.mute.lock().expect("Failed to lock mute") {
+            return;
+        }
+
         _ = self
             .logger
             .lock()
@@ -136,11 +158,19 @@
 
     /// Stops a loading message.
     fn done(&self) {
+        if *self.mute.lock().expect("Failed to lock mute") {
+            return;
+        }
+
         _ = self.logger.lock().expect("Failed to lock logger").done();
     }
 
     /// Adds a style to the logger.
     fn add_style(&self, name: &str, styles: Vec<&'static str>) -> &Self {
+        if *self.mute.lock().expect("Failed to lock mute") {
+            return self;
+        }
+
         _ = self
             .logger
             .lock()
@@ -151,6 +181,10 @@
 
     /// Logs a loading message with a spinner.
     fn loading(&self, message: &str) {
+        if *self.mute.lock().expect("Failed to lock mute") {
+            return;
+        }
+
         _ = self
             .logger
             .lock()
@@ -160,18 +194,31 @@
 
     /// Forces the logger to not print a newline for the next message.
     fn same(&self) -> &Self {
+        if *self.mute.lock().expect("Failed to lock mute") {
+            return self;
+        }
+
         _ = self.logger.lock().expect("Failed to lock logger").same();
         self
     }
 
     /// Logs a message without icon.
     fn log(&self, message: &str) {
+        if *self.mute.lock().expect("Failed to lock mute") {
+            return;
+        }
+
         _ = self
             .logger
             .lock()
             .expect("Failed to lock logger")
             .log(message);
     }
+
+    /// Mute all the messages except for the warnings and errors.
+    fn mute(&self) {
+        *self.mute.lock().expect("Failed to lock mute") = true;
+    }
 }
 
 /// A logger that does not log anything.
@@ -226,6 +273,9 @@
 
     /// Logs a message without icon.
     fn log(&self, _: &str) {}
+
+    /// Mute all the messages except for the warnings and errors.
+    fn mute(&self) {}
 }
 
 /// A logger that can be used in unit or integration tests.
@@ -363,4 +413,9 @@
             .expect("Failed to lock logger")
             .log(message);
     }
+
+    /// Mute all the messages except for the warnings and errors.
+    fn mute(&self) {
+        // We do not need to mute the logger in the tests.
+    }
 }

crates/weaver_common/src/quiet.rs

@@ -78,4 +78,9 @@
 
     /// Logs a message without icon.
     fn log(&self, _message: &str) {}
+
+    /// Mute all the messages except for the warnings and errors.
+    fn mute(&self) {
+        // Do nothing
+    }
 }

crates/weaver_forge/Cargo.toml

@@ -38,6 +38,7 @@ walkdir.workspace = true
 globset.workspace = true
 miette.workspace = true
 include_dir.workspace = true
+schemars.workspace = true
 
 [dev-dependencies]
 opentelemetry = { version = "0.22.0", features = ["trace", "metrics", "logs", "otel_unstable"] }

crates/weaver_forge/allowed-external-types.toml

@@ -12,4 +12,5 @@ allowed_external_types = [
     "minijinja::value::Value",
     "miette::protocol::Diagnostic",
     "include_dir::dir::Dir",
+    "schemars::JsonSchema",
 ]

crates/weaver_forge/src/lib.rs

@@ -29,7 +29,7 @@ use crate::debug::error_summary;
 use crate::error::Error::InvalidConfigFile;
 use crate::extensions::{ansi, case, code, otel, util};
 use crate::file_loader::FileLoader;
-use crate::registry::{TemplateGroup, TemplateRegistry};
+use crate::registry::{ResolvedGroup, ResolvedRegistry};
 
 mod config;
 pub mod debug;
@@ -109,11 +109,11 @@ pub struct TemplateEngine {
 #[derive(Serialize, Debug)]
 pub struct Context<'a> {
     /// The semantic convention registry.
-    pub registry: &'a TemplateRegistry,
+    pub registry: &'a ResolvedRegistry,
     /// The group to generate doc or code for.
-    pub group: Option<&'a TemplateGroup>,
+    pub group: Option<&'a ResolvedGroup>,
     /// The groups to generate doc or code for.
-    pub groups: Option<Vec<&'a TemplateGroup>>,
+    pub groups: Option<Vec<&'a ResolvedGroup>>,
 }
 
 /// Global context for the template engine.
@@ -432,7 +432,7 @@ mod tests {
     use crate::extensions::case::case_converter;
     use crate::file_loader::FileSystemFileLoader;
     use crate::filter::Filter;
-    use crate::registry::TemplateRegistry;
+    use crate::registry::ResolvedRegistry;
     use crate::OutputDirective;
 
     #[test]
@@ -580,7 +580,7 @@ mod tests {
         let schema = SchemaResolver::resolve_semantic_convention_registry(&mut registry)
             .expect("Failed to resolve registry");
 
-        let template_registry = TemplateRegistry::try_from_resolved_registry(
+        let template_registry = ResolvedRegistry::try_from_resolved_registry(
             schema.registry(registry_id).expect("registry not found"),
             schema.catalog(),
         )