Support for 2 semconv registries

crates/weaver_resolver/src/lib.rs

@@ -380,57 +380,48 @@ impl SchemaResolver {
         allow_registry_deps: bool,
         follow_symlinks: bool,
     ) -> Option<WResult<Vec<(Provenance, SemConvSpec)>, weaver_semconv::Error>> {
-        match registry_repo.manifest_path() {
-            Some(manifest_path) => {
-                match RegistryManifest::try_from_file(manifest_path) {
-                    Ok(manifest) => {
-                        if let Some(dependencies) =
-                            manifest.dependencies.filter(|deps| !deps.is_empty())
-                        {
-                            if !allow_registry_deps {
+        match registry_repo.manifest() {
+            Some(manifest) => {
+                if let Some(dependencies) = manifest
+                    .dependencies
+                    .as_ref()
+                    .filter(|deps| !deps.is_empty())
+                {
+                    if !allow_registry_deps {
+                        Some(WResult::FatalErr(weaver_semconv::Error::SemConvSpecError {
+                            error: format!(
+                                "Registry dependencies are not allowed for the `{}` registry. Weaver currently supports only two registry levels.",
+                                registry_repo.registry_path_repr()
+                            ),
+                        }))
+                    } else if dependencies.len() > 1 {
+                        Some(WResult::FatalErr(weaver_semconv::Error::SemConvSpecError {
+                            error: format!(
+                                "Currently, Weaver supports only a single dependency per registry. Multiple dependencies have been found in the `{}` registry.",
+                                registry_repo.registry_path_repr()
+                            ),
+                        }))
+                    } else {
+                        let dependency = &dependencies[0];
+                        match RegistryRepo::try_new(&dependency.name, &dependency.registry_path) {
+                            Ok(registry_repo_dep) => Some(Self::load_semconv_specs(
+                                &registry_repo_dep,
+                                false,
+                                follow_symlinks,
+                            )),
+                            Err(e) => {
                                 Some(WResult::FatalErr(weaver_semconv::Error::SemConvSpecError {
                                     error: format!(
-                                        "Registry dependencies are not allowed for the `{}` registry. Weaver currently supports only two registry levels.",
-                                        registry_repo.registry_path_repr()
+                                        "Failed to load the registry dependency `{}`: {}",
+                                        dependency.name, e
                                     ),
                                 }))
-                            } else if dependencies.len() > 1 {
-                                Some(WResult::FatalErr(weaver_semconv::Error::SemConvSpecError {
-                                    error: format!(
-                                        "Currently, Weaver supports only a single dependency per registry. Multiple dependencies have been found in the `{}` registry.",
-                                        registry_repo.registry_path_repr()
-                                    ),
-                                }))
-                            } else {
-                                let dependency = &dependencies[0];
-                                match RegistryRepo::try_new(
-                                    &dependency.name,
-                                    &dependency.registry_path,
-                                ) {
-                                    Ok(registry_repo_dep) => Some(Self::load_semconv_specs(
-                                        &registry_repo_dep,
-                                        false,
-                                        follow_symlinks,
-                                    )),
-                                    Err(e) => Some(WResult::FatalErr(
-                                        weaver_semconv::Error::SemConvSpecError {
-                                            error: format!(
-                                                "Failed to load the registry dependency `{}`: {}",
-                                                dependency.name, e
-                                            ),
-                                        },
-                                    )),
-                                }
                             }
-                        } else {
-                            // Manifest has no dependencies or dependencies are empty
-                            None
                         }
                     }
-                    Err(e) => {
-                        // Manifest file is not valid or not found
-                        Some(WResult::FatalErr(e))
-                    }
+                } else {
+                    // Manifest has no dependencies or dependencies are empty
+                    None
                 }
             }
             None => None,

crates/weaver_resolver/src/registry.rs

@@ -17,7 +17,8 @@ use weaver_resolved_schema::attribute::UnresolvedAttribute;
 use weaver_resolved_schema::lineage::{AttributeLineage, GroupLineage};
 use weaver_resolved_schema::registry::{Constraint, Group, Registry};
 use weaver_semconv::attribute::AttributeSpec;
-use weaver_semconv::group::GroupSpecWithProvenance;
+use weaver_semconv::group::{GroupSpecWithProvenance, GroupType};
+use weaver_semconv::manifest::RegistryManifest;
 use weaver_semconv::provenance::Provenance;
 use weaver_semconv::registry::SemConvRegistry;
 
@@ -152,9 +153,32 @@ pub fn resolve_semconv_registry(
     );
     check_root_attribute_id_duplicates(&ureg.registry, &attr_name_index, &mut errors);
 
+    gc_unreferenced_objects(registry.manifest(), &mut ureg.registry);
+
     WResult::OkWithNFEs(ureg.registry, errors)
 }
 
+/// Garbage collect all the signals and attributes not defined or referenced in the
+/// current registry, i.e. telemetry objects only defined in a dependency and not
+/// referenced in the current registry.
+fn gc_unreferenced_objects(manifest: Option<&RegistryManifest>, registry: &mut Registry) {
+    if let Some(manifest) = manifest {
+        if manifest.dependencies.as_ref().map_or(0, |d| d.len()) > 0 {
+            // This registry has dependencies.
+            let current_reg_id = manifest.name.clone();
+            println!("current registry id: {}", current_reg_id);
+            registry.groups.retain(|group| {
+                if let Some(lineage) = &group.lineage {
+                    println!("group registry id: {}", lineage.provenance().registry_id);
+                    lineage.provenance().registry_id.as_ref() == current_reg_id
+                } else {
+                    true
+                }
+            });
+        }
+    }
+}
+
 /// Checks the `any_of` constraints in the given registry.
 ///
 /// # Arguments

crates/weaver_semconv/src/registry.rs

@@ -129,9 +129,7 @@ impl SemConvRegistry {
             registry.add_semconv_spec(SemConvSpecWithProvenance { spec, provenance });
         }
 
-        if let Some(manifest_path) = registry_repo.manifest_path() {
-            registry.set_manifest(RegistryManifest::try_from_file(manifest_path)?);
-        } else {
+        if registry_repo.manifest().is_none() {
             let mut semconv_version = "unversioned".to_owned();
 
             // No registry manifest found.

crates/weaver_semconv/src/registry_repo.rs

@@ -10,6 +10,7 @@ use std::path::{Path, PathBuf};
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 
+use crate::manifest::RegistryManifest;
 use crate::registry_path::RegistryPath;
 use crate::Error;
 use crate::Error::{GitError, InvalidRegistryArchive, UnsupportedRegistryArchive};
@@ -37,6 +38,9 @@ pub struct RegistryRepo {
     id: Arc<str>,
     registry_path: String,
     path: PathBuf,
+    // The registry manifest definition.
+    manifest: Option<RegistryManifest>,
+
     // Need to keep the tempdir live for the lifetime of the RegistryRepo.
     #[allow(dead_code)]
     tmp_dir: Option<TempDir>,
@@ -45,24 +49,33 @@ pub struct RegistryRepo {
 impl RegistryRepo {
     /// Creates a new `RegistryRepo` from a `RegistryPath` object that
     /// specifies the location of the registry.
-    pub fn try_new(id: &str, registry_path: &RegistryPath) -> Result<Self, Error> {
+    pub fn try_new(
+        registry_id_if_no_manifest: &str,
+        registry_path: &RegistryPath,
+    ) -> Result<Self, Error> {
         let registry_path_repr = registry_path.to_string();
-        match registry_path {
+        let mut registry_repo = match registry_path {
             RegistryPath::LocalFolder { path } => Ok(Self {
-                id: Arc::from(id),
+                id: Arc::from(registry_id_if_no_manifest),
                 registry_path: registry_path_repr,
                 path: path.into(),
+                manifest: None,
                 tmp_dir: None,
             }),
             RegistryPath::GitRepo {
                 url, sub_folder, ..
-            } => Self::try_from_git_url(id, url, sub_folder, registry_path_repr),
+            } => Self::try_from_git_url(
+                registry_id_if_no_manifest,
+                url,
+                sub_folder,
+                registry_path_repr,
+            ),
             RegistryPath::LocalArchive { path, sub_folder } => {
                 // Create a temporary directory for the repo that will be deleted
                 // when the RegistryRepo goes out of scope.
                 let tmp_dir = Self::create_tmp_repo()?;
                 Self::try_from_local_archive(
-                    id,
+                    registry_id_if_no_manifest,
                     path,
                     sub_folder.as_ref(),
                     tmp_dir,
@@ -74,14 +87,22 @@ impl RegistryRepo {
                 // when the RegistryRepo goes out of scope.
                 let tmp_dir = Self::create_tmp_repo()?;
                 Self::try_from_remote_archive(
-                    id,
+                    registry_id_if_no_manifest,
                     url,
                     sub_folder.as_ref(),
                     tmp_dir,
                     registry_path_repr,
                 )
             }
+        };
+        if let Ok(registry_repo) = &mut registry_repo {
+            if let Some(manifest) = registry_repo.manifest_path() {
+                let registry_manifest = RegistryManifest::try_from_file(manifest)?;
+                registry_repo.id = Arc::from(registry_manifest.name.as_str());
+                registry_repo.manifest = Some(registry_manifest);
+            }
         }
+        registry_repo
     }
 
     /// Creates a new `RegistryRepo` from a Git URL.
@@ -150,6 +171,7 @@ impl RegistryRepo {
             id: Arc::from(id),
             registry_path,
             path,
+            manifest: None,
             tmp_dir: Some(tmp_dir),
         })
     }
@@ -201,6 +223,7 @@ impl RegistryRepo {
             id: Arc::from(id),
             registry_path,
             path: target_path_buf,
+            manifest: None,
             tmp_dir: Some(target_dir),
         })
     }
@@ -441,6 +464,12 @@ impl RegistryRepo {
         &self.registry_path
     }
 
+    /// Returns the registry manifest specified in the registry repo.
+    #[must_use]
+    pub fn manifest(&self) -> Option<&RegistryManifest> {
+        self.manifest.as_ref()
+    }
+
     /// Returns the path to the `registry_manifest.yaml` file (if any).
     #[must_use]
     pub fn manifest_path(&self) -> Option<PathBuf> {

crates/weaver_semconv/src/semconv.rs

@@ -203,7 +203,6 @@ mod tests {
         InvalidSemConvSpec, InvalidSpanMissingSpanKind, RegistryNotFound,
     };
     use std::path::PathBuf;
-    use std::process::id;
     use weaver_common::test::ServeStaticFiles;
 
     #[test]