Registry manifest and Schema diff

Cargo.toml

@@ -79,6 +79,7 @@ weaver_semconv_gen = { path = "crates/weaver_semconv_gen" }
 weaver_cache = { path = "crates/weaver_cache" }
 weaver_forge = { path = "crates/weaver_forge" }
 weaver_checker = { path = "crates/weaver_checker" }
+weaver_otel_schema = { path = "crates/weaver_otel_schema" }
 
 clap = { version = "4.5.23", features = ["derive"] }
 rayon = "1.10.0"

README.md

@@ -147,6 +147,7 @@ Semantic Convention Registries. The following commands are available:
 |---------------------------------------------------------------------------|---------------------------------------------|
 | [weaver registry check](docs/usage.md#registry-check)                     | Check the validity of a semconv registry    |
 | [weaver registry resolve](docs/usage.md#registry-resolve)                 | Resolve a semconv registry                  |
+| [weaver registry diff](docs/usage.md#registry-diff)                       | Generate a diff report between two versions |
 | [weaver registry generate](docs/usage.md#registry-generate)               | Generate artifacts from a semconv registry  |
 | [weaver registry update-markdown](docs/usage.md#registry-update-markdown) | Update semconv snippet-based markdown files |
 | [weaver registry stats](docs/usage.md#registry-stats)                     | Generate statistics on a semconv registry   |
@@ -162,6 +163,8 @@ Telemetry Schemas.
   documentation and code based on semantic conventions.
 - [Weaver Checker](crates/weaver_checker/README.md): An integrated policy
   engine for enforcing policies on semantic conventions.
+- [Schema Changes](docs/schema-changes.md): A document describing the data model
+  used to represent the differences between two versions of a semantic convention registry.
 - [Application Telemetry Schema OTEP](https://github.com/open-telemetry/oteps/blob/main/text/0243-app-telemetry-schema-vision-roadmap.md):
   A vision and roadmap for the concept of Application Telemetry Schema.
 - Presentation slides from the Semantic Convention SIG meeting on October 23,

crates/weaver_cache/src/lib.rs

@@ -29,6 +29,8 @@ pub mod registry_path;
 const TAR_GZ_EXT: &str = ".tar.gz";
 /// The extension for a zip archive.
 const ZIP_EXT: &str = ".zip";
+/// The name of the registry manifest file.
+const REGISTRY_MANIFEST: &str = "registry_manifest.yaml";
 
 /// An error that can occur while creating or using a cache.
 #[derive(thiserror::Error, Debug, Clone, Serialize, Diagnostic)]
@@ -99,7 +101,7 @@ impl From<Error> for DiagnosticMessages {
 /// - A simple wrapper around a local directory
 /// - Initialized from a Git repository
 /// - Initialized from a Git archive
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct RegistryRepo {
     // A unique identifier for the registry (e.g. main, baseline, etc.)
     id: String,
@@ -509,6 +511,17 @@ impl RegistryRepo {
         &self.registry_path
     }
 
+    /// Returns the path to the `registry_manifest.yaml` file (if any).
+    #[must_use]
+    pub fn manifest_path(&self) -> Option<PathBuf> {
+        let manifest_path = self.path.join(REGISTRY_MANIFEST);
+        if manifest_path.exists() {
+            Some(manifest_path)
+        } else {
+            None
+        }
+    }
+
     /// Creates a temporary directory for the registry repository and returns the path.
     /// The temporary directory is created in the `.weaver/semconv_registry_cache`.
     fn create_tmp_repo() -> Result<TempDir, Error> {

crates/weaver_codegen_test/build.rs

@@ -24,7 +24,6 @@ use weaver_semconv::registry::SemConvRegistry;
 
 const SEMCONV_REGISTRY_PATH: &str = "./semconv_registry/";
 const TEMPLATES_PATH: &str = "./templates/registry/";
-const REGISTRY_ID: &str = "test";
 const TARGET: &str = "rust";
 const FOLLOW_SYMLINKS: bool = false;
 
@@ -50,22 +49,20 @@ fn main() {
         .ignore(|e| matches!(e.severity(), Some(miette::Severity::Warning)))
         .into_result_failing_non_fatal()
         .unwrap_or_else(|e| process_error(&logger, e));
-    let mut registry = SemConvRegistry::from_semconv_specs(REGISTRY_ID, semconv_specs);
+    let mut registry = SemConvRegistry::from_semconv_specs(&registry_repo, semconv_specs)
+        .unwrap_or_else(|e| process_error(&logger, e));
     let schema = SchemaResolver::resolve_semantic_convention_registry(&mut registry)
+        .into_result_failing_non_fatal()
         .unwrap_or_else(|e| process_error(&logger, e));
 
     let loader = FileSystemFileLoader::try_new(TEMPLATES_PATH.into(), TARGET)
         .unwrap_or_else(|e| process_error(&logger, e));
     let config = WeaverConfig::try_from_path("./templates/registry/rust")
         .unwrap_or_else(|e| process_error(&logger, e));
     let engine = TemplateEngine::new(config, loader, Params::default());
-    let template_registry = ResolvedRegistry::try_from_resolved_registry(
-        schema
-            .registry(REGISTRY_ID)
-            .expect("Failed to get the registry from the resolved schema"),
-        schema.catalog(),
-    )
-    .unwrap_or_else(|e| process_error(&logger, e));
+    let template_registry =
+        ResolvedRegistry::try_from_resolved_registry(&schema.registry, schema.catalog())
+            .unwrap_or_else(|e| process_error(&logger, e));
     let target_dir: PathBuf = target_dir.into();
     engine
         .generate(

crates/weaver_common/src/diagnostic.rs

@@ -75,6 +75,12 @@ pub struct DiagnosticMessage {
 #[serde(transparent)]
 pub struct DiagnosticMessages(Vec<DiagnosticMessage>);
 
+impl From<DiagnosticMessage> for DiagnosticMessages {
+    fn from(value: DiagnosticMessage) -> Self {
+        Self(vec![value])
+    }
+}
+
 impl DiagnosticMessage {
     /// Creates a new diagnostic message from an error
     pub fn new<M: Error + Diagnostic + Serialize + Send + Sync + 'static>(error: M) -> Self {
@@ -180,8 +186,7 @@ impl DiagnosticMessages {
         Self(vec![DiagnosticMessage::new(error)])
     }
 
-    /// Returns true if all the diagnostic messages are explicitly marked as
-    /// warnings or advices.
+    /// Returns true if at least one diagnostic message has an error severity.
     #[must_use]
     pub fn has_error(&self) -> bool {
         let non_error_count = self
@@ -242,7 +247,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use miette::{diagnostic, Diagnostic};
+    use miette::Diagnostic;
 
     #[derive(thiserror::Error, Debug, Clone, Diagnostic, Serialize)]
     #[error("This is a test error")]

crates/weaver_common/src/result.rs

@@ -27,10 +27,50 @@ pub enum WResult<T, E> {
     FatalErr(E),
 }
 
+impl<T> WResult<T, DiagnosticMessage> {
+    /// Converts a [`WResult`] into a standard [`Result`], optionally capturing non-fatal errors.
+    pub fn capture_non_fatal_errors(
+        self,
+        diag_msgs: &mut DiagnosticMessages,
+    ) -> Result<T, DiagnosticMessage> {
+        match self {
+            WResult::Ok(result) => Ok(result),
+            WResult::OkWithNFEs(result, nfes) => {
+                diag_msgs.extend_from_vec(nfes);
+                Ok(result)
+            }
+            WResult::FatalErr(fatal_err) => Err(fatal_err),
+        }
+    }
+}
+
 impl<T, E> WResult<T, E>
 where
     E: WeaverError<E> + Error + Diagnostic + Serialize + Send + Sync + 'static,
 {
+    /// Returns `true` if the result is a fatal error.
+    pub fn is_fatal(&self) -> bool {
+        matches!(self, WResult::FatalErr(_))
+    }
+
+    /// Returns `true` if the result is not Ok.
+    pub fn has_errors(&self) -> bool {
+        match self {
+            WResult::Ok(_) => false,
+            WResult::OkWithNFEs(_, errors) => !errors.is_empty(),
+            WResult::FatalErr(_) => true,
+        }
+    }
+
+    /// Returns the number of non-fatal errors, or 1 if the result is a fatal error, 0 otherwise.
+    pub fn error_count(&self) -> usize {
+        match self {
+            WResult::Ok(_) => 0,
+            WResult::OkWithNFEs(_, errors) => errors.len(),
+            WResult::FatalErr(_) => 1,
+        }
+    }
+
     /// Creates a new [`WResult`] with a successful result.
     pub fn with_non_fatal_errors(result: T, non_fatal_errors: Vec<E>) -> Self {
         if non_fatal_errors.is_empty() {

crates/weaver_forge/expected_output/test/resource/library.md

@@ -22,7 +22,7 @@ Brief: Span attributes used by non-OTLP exporters to represent OpenTelemetry Sco
 - Examples: [
     "io.opentelemetry.contrib.mongodb",
 ]
-- Deprecated: use the `otel.scope.name` attribute.
+- Deprecated: 
 
 
 #### Attribute `otel.library.version`
@@ -36,7 +36,7 @@ Brief: Span attributes used by non-OTLP exporters to represent OpenTelemetry Sco
 - Examples: [
     "1.0.0",
 ]
-- Deprecated: use the `otel.scope.version` attribute.
+- Deprecated: 
 
 
 

crates/weaver_forge/expected_output/test/resources.md

@@ -25,7 +25,7 @@ Brief: Span attributes used by non-OTLP exporters to represent OpenTelemetry Sco
 - Examples: [
     "io.opentelemetry.contrib.mongodb",
 ]
-- Deprecated: use the `otel.scope.name` attribute.
+- Deprecated: 
 
 
 #### Attribute `otel.library.version`
@@ -39,7 +39,7 @@ Brief: Span attributes used by non-OTLP exporters to represent OpenTelemetry Sco
 - Examples: [
     "1.0.0",
 ]
-- Deprecated: use the `otel.scope.version` attribute.
+- Deprecated: 
 
 
 

crates/weaver_forge/src/lib.rs

@@ -721,13 +721,12 @@ mod tests {
         let registry = SemConvRegistry::try_from_path_pattern(registry_id, "data/*.yaml")
             .into_result_failing_non_fatal()
             .expect("Failed to load registry");
-        prepare_test_with_registry(target, cli_params, registry_id, registry)
+        prepare_test_with_registry(target, cli_params, registry)
     }
 
     fn prepare_test_with_registry(
         target: &str,
         cli_params: Params,
-        registry_id: &str,
         mut registry: SemConvRegistry,
     ) -> (
         TestLogger,
@@ -741,18 +740,17 @@ mod tests {
         let config = WeaverConfig::try_from_path(format!("templates/{}", target)).unwrap();
         let engine = TemplateEngine::new(config, loader, cli_params);
         let schema = SchemaResolver::resolve_semantic_convention_registry(&mut registry)
+            .into_result_failing_non_fatal()
             .expect("Failed to resolve registry");
 
-        let template_registry = ResolvedRegistry::try_from_resolved_registry(
-            schema.registry(registry_id).expect("registry not found"),
-            schema.catalog(),
-        )
-        .unwrap_or_else(|e| {
-            panic!(
-                "Failed to create the context for the template evaluation: {:?}",
-                e
-            )
-        });
+        let template_registry =
+            ResolvedRegistry::try_from_resolved_registry(&schema.registry, schema.catalog())
+                .unwrap_or_else(|e| {
+                    panic!(
+                        "Failed to create the context for the template evaluation: {:?}",
+                        e
+                    )
+                });
 
         // Delete all the files in the observed_output/target directory
         // before generating the new files.
@@ -920,18 +918,17 @@ mod tests {
             .into_result_failing_non_fatal()
             .expect("Failed to load registry");
         let schema = SchemaResolver::resolve_semantic_convention_registry(&mut registry)
+            .into_result_failing_non_fatal()
             .expect("Failed to resolve registry");
 
-        let template_registry = ResolvedRegistry::try_from_resolved_registry(
-            schema.registry(registry_id).expect("registry not found"),
-            schema.catalog(),
-        )
-        .unwrap_or_else(|e| {
-            panic!(
-                "Failed to create the context for the template evaluation: {:?}",
-                e
-            )
-        });
+        let template_registry =
+            ResolvedRegistry::try_from_resolved_registry(&schema.registry, schema.catalog())
+                .unwrap_or_else(|e| {
+                    panic!(
+                        "Failed to create the context for the template evaluation: {:?}",
+                        e
+                    )
+                });
 
         engine
             .generate(
@@ -1056,7 +1053,7 @@ mod tests {
         .into_result_failing_non_fatal()
         .expect("Failed to load registry");
         let (logger, engine, template_registry, observed_output, expected_output) =
-            prepare_test_with_registry("comment_format", Params::default(), registry_id, registry);
+            prepare_test_with_registry("comment_format", Params::default(), registry);
 
         engine
             .generate(

crates/weaver_forge/src/registry.rs

@@ -12,6 +12,7 @@ use weaver_resolved_schema::catalog::Catalog;
 use weaver_resolved_schema::lineage::GroupLineage;
 use weaver_resolved_schema::registry::{Constraint, Group, Registry};
 use weaver_semconv::any_value::AnyValueSpec;
+use weaver_semconv::deprecated::Deprecated;
 use weaver_semconv::group::{GroupType, InstrumentSpec, SpanKindSpec};
 use weaver_semconv::stability::Stability;
 
@@ -63,7 +64,7 @@ pub struct ResolvedGroup {
     /// provided as `description` MUST specify why it's deprecated and/or what
     /// to use instead. See also stability.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub deprecated: Option<String>,
+    pub deprecated: Option<Deprecated>,
     /// Additional constraints.
     /// Allow to define additional requirements on the semantic convention.
     /// It defaults to an empty list.

crates/weaver_forge/templates/test/resource.md

@@ -39,7 +39,7 @@ Brief: {{ resource.brief }}
 - Sampling relevant: {{ attribute.sampling_relevant }}
   {%- endif %}
   {%- if attribute.deprecated %}
-- Deprecated: {{ attribute.deprecated }}
+- Deprecated: {{ attribute.deprecated.note }}
   {%- endif %}
   {% if attribute.stability %}
 - Stability: {{ attribute.stability | capitalize }}

crates/weaver_forge/templates/test/resources.md

@@ -39,7 +39,7 @@ Brief: {{ resource.brief }}
 - Sampling relevant: {{ attribute.sampling_relevant }}
   {%- endif %}
   {%- if attribute.deprecated %}
-- Deprecated: {{ attribute.deprecated }}
+- Deprecated: {{ attribute.note }}
   {%- endif %}
   {% if attribute.stability %}
 - Stability: {{ attribute.stability | capitalize }}

crates/weaver_otel_schema/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "weaver_otel_schema"
+version = "0.10.0"
+authors.workspace = true
+repository.workspace = true
+license.workspace = true
+publish.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+weaver_version = { path = "../weaver_version" }
+weaver_common = { path = "../weaver_common" }
+
+thiserror.workspace = true
+serde.workspace = true
+serde_yaml.workspace = true
+miette.workspace = true