Add spans to resolved registry.

Author: jsuereth

crates/weaver_forge/src/v2/mod.rs

@@ -3,3 +3,4 @@
 pub mod attribute;
 pub mod metric;
 pub mod registry;
+pub mod span;

crates/weaver_forge/src/v2/registry.rs

@@ -8,7 +8,7 @@ use crate::{
     error::Error,
     v2::{
         attribute::Attribute,
-        metric::{Metric, MetricAttribute, MetricRefinement},
+        metric::{Metric, MetricAttribute, MetricRefinement}, span::{Span, SpanAttribute, SpanRefinement},
     },
 };
 
@@ -35,6 +35,8 @@ pub struct ResolvedRegistry {
 pub struct Signals {
     /// The metric signals defined.
     pub metrics: Vec<Metric>,
+    /// The span signals defined.
+    pub spans: Vec<Span>,
 }
 
 /// The set of all refinements for a semantic convention registry.
@@ -47,6 +49,8 @@ pub struct Signals {
 pub struct Refinements {
     /// The metric refinements defined.
     pub metrics: Vec<MetricRefinement>,
+    /// The span refinements defined.
+    pub spans: Vec<SpanRefinement>,
 }
 
 impl ResolvedRegistry {
@@ -127,15 +131,89 @@ impl ResolvedRegistry {
             });
         }
 
+        let mut spans = Vec::new();
+        for span in schema.registry.spans {
+            let attributes = span
+                .attributes
+                .iter()
+                .filter_map(|ar| {
+                    let attr = schema.catalog.attribute(&ar.base).map(|a| SpanAttribute {
+                        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(),
+                        sampling_relevant: ar.sampling_relevant.clone(),
+                    });
+                    if attr.is_none() {
+                        errors.push(Error::AttributeNotFound {
+                            group_id: format!("span.{}", &span.r#type),
+                            attr_ref: AttributeRef(ar.base.0),
+                        });
+                    }
+                    attr
+                })
+                .collect();
+            spans.push(Span {
+                r#type: span.r#type,
+                kind: span.kind,
+                name: span.name,
+                attributes,
+                entity_associations: span.entity_associations,
+                common: span.common,
+            });
+        }
+        let mut span_refinements = Vec::new();
+        for span in schema.registry.span_refinements {
+            let attributes = span
+                .span
+                .attributes
+                .iter()
+                .filter_map(|ar| {
+                    let attr = schema.catalog.attribute(&ar.base).map(|a| SpanAttribute {
+                        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(),
+                        sampling_relevant: ar.sampling_relevant.clone(),
+                    });
+                    if attr.is_none() {
+                        errors.push(Error::AttributeNotFound {
+                            group_id: format!("span.{}", &span.id),
+                            attr_ref: AttributeRef(ar.base.0),
+                        });
+                    }
+                    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,
+            }
+                });
+        }
         if !errors.is_empty() {
             return Err(Error::CompoundError(errors));
         }
 
         Ok(Self {
             registry_url: schema.schema_url.clone(),
-            signals: Signals { metrics },
+            signals: Signals { metrics, spans },
             refinements: Refinements {
                 metrics: metric_refinements,
+                spans: span_refinements,
             },
         })
     }

crates/weaver_forge/src/v2/span.rs

@@ -0,0 +1,81 @@
+//! Span related definitions structs.
+
+use crate::v2::attribute::Attribute;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use weaver_semconv::{
+    attribute::RequirementLevel,
+    group::SpanKindSpec,
+    v2::{signal_id::SignalId, span::SpanName, CommonFields},
+};
+
+/// The definition of a span signal.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct Span {
+    /// The type of the Span. This denotes the identity
+    /// of the "shape" of this span, and must be unique.
+    pub r#type: SignalId,
+    /// Specifies the kind of the span.
+    pub kind: SpanKindSpec,
+    /// The name pattern for the span.
+    pub name: SpanName,
+    /// List of attributes that should be included on this span.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub attributes: Vec<SpanAttribute>,
+    /// Which resources this span should be associated with.
+    ///
+    /// This list is an "any of" list, where a span 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 span-specicific information.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct SpanAttribute {
+    /// 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,
+
+    /// Specifies if the attribute is (especially) relevant for sampling
+    /// and thus should be set at span start. It defaults to false.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sampling_relevant: Option<bool>,
+}
+
+/// A refinement of a span signal, for use in code-gen or specific library application.
+///
+/// A refinement represents a "view" of a Span that is highly optimised for a particular implementation.
+/// e.g. for HTTP spans, 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 span.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
+pub struct SpanRefinement {
+    /// 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 span: Span,
+}