Add the remaining missing pieces to V2 resolved schema.

Author: jsuereth

crates/weaver_forge/src/v2/entity.rs

@@ -0,0 +1,51 @@
+//! Event related definitions structs.
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use weaver_semconv::{
+    attribute::RequirementLevel,
+    v2::{signal_id::SignalId, CommonFields},
+};
+
+use crate::v2::attribute::Attribute;
+
+/// The definition of an event signal.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct Entity {
+    /// The type of the entity.
+    pub r#type: SignalId,
+
+    /// List of attributes that belong to this event.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub identity: Vec<EntityAttribute>,
+
+    /// List of attributes that belong to this event.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub description: Vec<EntityAttribute>,
+
+    /// Common fields (like brief, note, annotations).
+    #[serde(flatten)]
+    pub common: CommonFields,
+}
+
+/// A special type of reference to attributes that remembers event-specicific information.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct EntityAttribute {
+    /// Base attribute definitions.
+    #[serde(flatten)]
+    pub base: Attribute,
+    /// Specifies if the attribute is mandatory. Can be "required",
+    /// "conditionally_required", "recommended" or "opt_in". When omitted,
+    /// the attribute is "recommended". When set to
+    /// "conditionally_required", the string provided as <condition> MUST
+    /// specify the conditions under which the attribute is required.
+    ///
+    /// Note: For attributes that are "recommended" or "opt-in" - not all metric source will
+    /// create timeseries with these attributes, but for any given timeseries instance, the attributes that *were* present
+    /// should *remain* present. That is - a metric timeseries cannot drop attributes during its lifetime.
+    pub requirement_level: RequirementLevel,
+}

crates/weaver_forge/src/v2/event.rs

@@ -0,0 +1,73 @@
+//! Event related definitions structs.
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use weaver_semconv::{
+    attribute::RequirementLevel,
+    v2::{signal_id::SignalId, CommonFields},
+};
+
+use crate::v2::attribute::Attribute;
+
+/// The definition of an event signal.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct Event {
+    /// The name of the event.
+    pub name: SignalId,
+
+    /// List of attributes that belong to this event.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub attributes: Vec<EventAttribute>,
+
+    /// Which resources this span should be associated with.
+    ///
+    /// This list is an "any of" list, where a metric may be associated with one or more entities, but should
+    /// be associated with at least one in this list.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub entity_associations: Vec<String>,
+
+    /// Common fields (like brief, note, annotations).
+    #[serde(flatten)]
+    pub common: CommonFields,
+}
+
+/// A special type of reference to attributes that remembers event-specicific information.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct EventAttribute {
+    /// Base attribute definitions.
+    #[serde(flatten)]
+    pub base: Attribute,
+    /// Specifies if the attribute is mandatory. Can be "required",
+    /// "conditionally_required", "recommended" or "opt_in". When omitted,
+    /// the attribute is "recommended". When set to
+    /// "conditionally_required", the string provided as <condition> MUST
+    /// specify the conditions under which the attribute is required.
+    ///
+    /// Note: For attributes that are "recommended" or "opt-in" - not all metric source will
+    /// create timeseries with these attributes, but for any given timeseries instance, the attributes that *were* present
+    /// should *remain* present. That is - a metric timeseries cannot drop attributes during its lifetime.
+    pub requirement_level: RequirementLevel,
+}
+
+/// A refinement of an event signal, for use in code-gen or specific library application.
+///
+/// A refinement represents a "view" of an Event that is highly optimised for a particular implementation.
+/// e.g. for HTTP events, there may be a refinement that provides only the necessary information for dealing with Java's HTTP
+/// client library, and drops optional or extraneous information from the underlying http event.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
+pub struct EventRefinement {
+    /// The identity of the refinement.
+    pub id: SignalId,
+
+    // TODO - This is a lazy way of doing this.  We use `type` to refer
+    // to the underlying span defintiion, but override all fields here.
+    // We probably should copy-paste all the "span" attributes here
+    // including the `ty`
+    /// The definition of the metric refinement.
+    #[serde(flatten)]
+    pub event: Event,
+}

crates/weaver_forge/src/v2/mod.rs

@@ -1,6 +1,8 @@
 //! Version two of weaver model.
 
 pub mod attribute;
+pub mod entity;
+pub mod event;
 pub mod metric;
 pub mod registry;
 pub mod span;

crates/weaver_forge/src/v2/registry.rs

@@ -8,7 +8,10 @@ use crate::{
     error::Error,
     v2::{
         attribute::Attribute,
-        metric::{Metric, MetricAttribute, MetricRefinement}, span::{Span, SpanAttribute, SpanRefinement},
+        entity::{Entity, EntityAttribute},
+        event::{Event, EventAttribute, EventRefinement},
+        metric::{Metric, MetricAttribute, MetricRefinement},
+        span::{Span, SpanAttribute, SpanRefinement},
     },
 };
 
@@ -22,7 +25,8 @@ pub struct ResolvedRegistry {
     /// The semantic convention registry url.
     #[serde(skip_serializing_if = "String::is_empty")]
     pub registry_url: String,
-    // TODO - Attribute registry?
+    /// The raw attributes in this registry.
+    pub attributes: Vec<Attribute>,
     /// The signals defined in this registry.
     pub signals: Signals,
     /// The set of refinments defined in this registry.
@@ -37,6 +41,10 @@ pub struct Signals {
     pub metrics: Vec<Metric>,
     /// The span signals defined.
     pub spans: Vec<Span>,
+    /// The event signals defined.
+    pub events: Vec<Event>,
+    /// The entity signals defined.
+    pub entities: Vec<Entity>,
 }
 
 /// The set of all refinements for a semantic convention registry.
@@ -51,6 +59,8 @@ pub struct Refinements {
     pub metrics: Vec<MetricRefinement>,
     /// The span refinements defined.
     pub spans: Vec<SpanRefinement>,
+    /// The event refinements defined.
+    pub events: Vec<EventRefinement>,
 }
 
 impl ResolvedRegistry {
@@ -59,6 +69,18 @@ impl ResolvedRegistry {
         schema: weaver_resolved_schema::v2::ResolvedTelemetrySchema,
     ) -> Result<Self, Error> {
         let mut errors = Vec::new();
+        let mut attributes: Vec<Attribute> = 
+            schema.catalog.attributes()
+            .iter()
+            .map(|a| Attribute {
+                key: a.key.clone(),
+                r#type: a.r#type.clone(),
+                examples: a.examples.clone(),
+                common: a.common.clone(),
+            })
+            .collect();
+        attributes.sort_by(|l,r| l.key.cmp(&r.key));
+
         let mut metrics = Vec::new();
         for metric in schema.registry.metrics {
             let attributes = metric
@@ -92,6 +114,7 @@ impl ResolvedRegistry {
                 common: metric.common,
             });
         }
+        metrics.sort_by(|l,r| l.name.cmp(&r.name));
 
         let mut metric_refinements: Vec<MetricRefinement> = Vec::new();
         for metric in schema.registry.metric_refinements {
@@ -130,6 +153,7 @@ impl ResolvedRegistry {
                 },
             });
         }
+        metric_refinements.sort_by(|l,r| l.id.cmp(&r.id));
 
         let mut spans = Vec::new();
         for span in schema.registry.spans {
@@ -165,6 +189,7 @@ impl ResolvedRegistry {
                 common: span.common,
             });
         }
+        spans.sort_by(|l,r| l.r#type.cmp(&r.r#type));
         let mut span_refinements = Vec::new();
         for span in schema.registry.span_refinements {
             let attributes = span
@@ -191,29 +216,164 @@ impl ResolvedRegistry {
                     attr
                 })
                 .collect();
-            span_refinements.push(
-                SpanRefinement { 
-                    id: span.id, 
-                    span: Span {
-                r#type: span.span.r#type,
-                kind: span.span.kind,
-                name: span.span.name,
-                attributes,
-                entity_associations: span.span.entity_associations,
-                common: span.span.common,
-            }
-                });
+            span_refinements.push(SpanRefinement {
+                id: span.id,
+                span: Span {
+                    r#type: span.span.r#type,
+                    kind: span.span.kind,
+                    name: span.span.name,
+                    attributes,
+                    entity_associations: span.span.entity_associations,
+                    common: span.span.common,
+                },
+            });
+        }
+        span_refinements.sort_by(|l,r| l.id.cmp(&r.id));
+
+        let mut events = Vec::new();
+        for event in schema.registry.events {
+            let attributes = event
+                .attributes
+                .iter()
+                .filter_map(|ar| {
+                    let attr = schema.catalog.attribute(&ar.base).map(|a| EventAttribute {
+                        base: Attribute {
+                            key: a.key.clone(),
+                            r#type: a.r#type.clone(),
+                            examples: a.examples.clone(),
+                            common: a.common.clone(),
+                        },
+                        requirement_level: ar.requirement_level.clone(),
+                    });
+                    if attr.is_none() {
+                        errors.push(Error::AttributeNotFound {
+                            group_id: format!("event.{}", &event.name),
+                            attr_ref: AttributeRef(ar.base.0),
+                        });
+                    }
+                    attr
+                })
+                .collect();
+            events.push(Event {
+                name: event.name,
+                attributes: attributes,
+                entity_associations: event.entity_associations,
+                common: event.common,
+            });
+        }
+        events.sort_by(|l,r| l.name.cmp(&r.name));
+
+        // convert event refinements.
+        let mut event_refinements = Vec::new();
+        for event in schema.registry.event_refinements {
+            let attributes = event
+                .event
+                .attributes
+                .iter()
+                .filter_map(|ar| {
+                    let attr = schema.catalog.attribute(&ar.base).map(|a| EventAttribute {
+                        base: Attribute {
+                            key: a.key.clone(),
+                            r#type: a.r#type.clone(),
+                            examples: a.examples.clone(),
+                            common: a.common.clone(),
+                        },
+                        requirement_level: ar.requirement_level.clone(),
+                    });
+                    if attr.is_none() {
+                        errors.push(Error::AttributeNotFound {
+                            group_id: format!("event.{}", &event.id),
+                            attr_ref: AttributeRef(ar.base.0),
+                        });
+                    }
+                    attr
+                })
+                .collect();
+            event_refinements.push(EventRefinement {
+                id: event.id,
+                event: Event {
+                    name: event.event.name,
+                    attributes: attributes,
+                    entity_associations: event.event.entity_associations,
+                    common: event.event.common,
+                },
+            });
+        }
+        event_refinements.sort_by(|l,r| l.id.cmp(&r.id));
+
+        let mut entities = Vec::new();
+        for e in schema.registry.entities {
+            let identity = e
+                .identity
+                .iter()
+                .filter_map(|ar| {
+                    let attr = schema.catalog.attribute(&ar.base).map(|a| EntityAttribute {
+                        base: Attribute {
+                            key: a.key.clone(),
+                            r#type: a.r#type.clone(),
+                            examples: a.examples.clone(),
+                            common: a.common.clone(),
+                        },
+                        requirement_level: ar.requirement_level.clone(),
+                    });
+                    if attr.is_none() {
+                        errors.push(Error::AttributeNotFound {
+                            group_id: format!("entity.{}", &e.r#type),
+                            attr_ref: AttributeRef(ar.base.0),
+                        });
+                    }
+                    attr
+                })
+                .collect();
+
+            let description = e
+                .description
+                .iter()
+                .filter_map(|ar| {
+                    let attr = schema.catalog.attribute(&ar.base).map(|a| EntityAttribute {
+                        base: Attribute {
+                            key: a.key.clone(),
+                            r#type: a.r#type.clone(),
+                            examples: a.examples.clone(),
+                            common: a.common.clone(),
+                        },
+                        requirement_level: ar.requirement_level.clone(),
+                    });
+                    if attr.is_none() {
+                        errors.push(Error::AttributeNotFound {
+                            group_id: format!("entity.{}", &e.r#type),
+                            attr_ref: AttributeRef(ar.base.0),
+                        });
+                    }
+                    attr
+                })
+                .collect();
+            entities.push(Entity {
+                r#type: e.r#type,
+                identity,
+                description,
+                common: e.common,
+            });
         }
+        entities.sort_by(|l,r| l.r#type.cmp(&r.r#type));
+
         if !errors.is_empty() {
             return Err(Error::CompoundError(errors));
         }
 
         Ok(Self {
             registry_url: schema.schema_url.clone(),
-            signals: Signals { metrics, spans },
+            attributes,
+            signals: Signals {
+                metrics,
+                spans,
+                events,
+                entities,
+            },
             refinements: Refinements {
                 metrics: metric_refinements,
                 spans: span_refinements,
+                events: event_refinements,
             },
         })
     }