[WIP] 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"

crates/weaver_cache/src/lib.rs

@@ -29,6 +29,8 @@
 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: &'static 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 @@
 /// - 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 @@
         &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,7 +49,8 @@ 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)
         .unwrap_or_else(|e| process_error(&logger, e));
 
@@ -62,13 +62,9 @@ fn main() {
     engine
         .import_jq_package(SEMCONV_JQ)
         .unwrap_or_else(|e| process_error(&logger, e));
-    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

@@ -180,8 +180,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

crates/weaver_forge/src/lib.rs

@@ -755,13 +755,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,
@@ -779,16 +778,14 @@ mod tests {
         let schema = SchemaResolver::resolve_semantic_convention_registry(&mut registry)
             .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.
@@ -959,16 +956,14 @@ mod tests {
         let schema = SchemaResolver::resolve_semantic_convention_registry(&mut registry)
             .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(
@@ -1093,7 +1088,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.deprecated.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

crates/weaver_otel_schema/README.md

@@ -0,0 +1,3 @@
+# OpenTelemetry Schema Data Model
+
+This crate describes the data model for the OpenTelemetry telemetry schema.

crates/weaver_otel_schema/allowed-external-types.toml

@@ -0,0 +1,6 @@
+# Copyright The OpenTelemetry Authors
+# SPDX-License-Identifier: Apache-2.0
+# This is used with cargo-check-external-types to reduce the surface area of downstream crates from
+# the public API. Ideally this can have a few exceptions as possible.
+allowed_external_types = [
+]

crates/weaver_otel_schema/src/lib.rs

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: Apache-2.0
+
+//! OpenTelemetry Schema Definitions
+//! Please refer to the [OpenTelemetry Schema OTEP](https://github.com/open-telemetry/oteps/blob/main/text/0152-telemetry-schemas.md)
+//! for more information.
+
+use crate::Error::{InvalidTelemetrySchema, TelemetrySchemaNotFound};
+use miette::Diagnostic;
+use serde::{Deserialize, Serialize};
+use weaver_common::diagnostic::{DiagnosticMessage, DiagnosticMessages};
+use weaver_version::Versions;
+
+/// Errors emitted by this crate.
+#[derive(thiserror::Error, Debug, Clone, Deserialize, Serialize, Diagnostic)]
+pub enum Error {
+    /// OTel Telemetry schema not found.
+    #[error("OTel telemetry schema not found (path_or_url: {path_or_url:?}).")]
+    TelemetrySchemaNotFound {
+        /// The path or the url to the telemetry schema file.
+        path_or_url: String,
+    },
+
+    /// Invalid OTel Telemetry schema.
+    #[error("Invalid OTel telemetry schema (path_or_url: {path_or_url:?}). {error}")]
+    InvalidTelemetrySchema {
+        /// The path or the url to the telemetry schema file.
+        path_or_url: String,
+        /// The error that occurred.
+        error: String,
+    },
+}
+
+impl From<Error> for DiagnosticMessages {
+    fn from(error: Error) -> Self {
+        DiagnosticMessages::new(vec![DiagnosticMessage::new(error)])
+    }
+}
+
+/// An OpenTelemetry Telemetry Schema.
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct TelemetrySchema {
+    /// Version of the file structure.
+    pub file_format: String,
+    /// Schema URL that this file is published at.
+    pub schema_url: String,
+    /// Definitions for each schema version in this family.
+    /// Note: the ordering of versions is defined according to semver
+    /// version number ordering rules.
+    /// This section is described in more details in the OTEP 0152 and in a dedicated
+    /// section below.
+    /// <https://github.com/open-telemetry/oteps/blob/main/text/0152-telemetry-schemas.md>
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub versions: Option<Versions>,
+}
+
+impl TelemetrySchema {
+    /// Attempts to load a telemetry schema from a file.
+    pub fn try_from_file<P: AsRef<std::path::Path>>(path: P) -> Result<Self, Error> {
+        let schema_path_buf = path.as_ref().to_path_buf();
+
+        if !schema_path_buf.exists() {
+            return Err(TelemetrySchemaNotFound {
+                path_or_url: schema_path_buf.as_path().to_string_lossy().to_string(),
+            });
+        }
+
+        let file = std::fs::File::open(path).map_err(|e| InvalidTelemetrySchema {
+            path_or_url: schema_path_buf.as_path().to_string_lossy().to_string(),
+            error: e.to_string(),
+        })?;
+        let reader = std::io::BufReader::new(file);
+        let schema: TelemetrySchema =
+            serde_yaml::from_reader(reader).map_err(|e| InvalidTelemetrySchema {
+                path_or_url: schema_path_buf.as_path().to_string_lossy().to_string(),
+                error: e.to_string(),
+            })?;
+
+        Ok(schema)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::TelemetrySchema;
+
+    #[test]
+    fn test_try_from_file() {
+        let schema = TelemetrySchema::try_from_file("tests/test_data/1.27.0.yaml").unwrap();
+        assert_eq!(schema.file_format, "1.1.0");
+        assert_eq!(schema.schema_url, "https://opentelemetry.io/schemas/1.27.0");
+    }
+}