chore(tracing): Use upstream semantic convention definitions

The proxy's tracing labels currently use hardcoded strings for semantic convention labels. This replaces those with the upstream ones defined by the OpenTelemetry libraries.

Signed-off-by: Scott Fleener <scott@buoyant.io>

Author: sfleen

Cargo.lock

@@ -379,6 +379,26 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "const_format"
+version = "0.2.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7faa7469a93a566e9ccc1c73fe783b4a65c274c5ace346038dca9c39fe0030ad"
+dependencies = [
+ "const_format_proc_macros",
+]
+
+[[package]]
+name = "const_format_proc_macros"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
 [[package]]
 name = "cpp_demangle"
 version = "0.4.5"
@@ -2066,6 +2086,7 @@ dependencies = [
  "linkerd-tracing",
  "opentelemetry",
  "opentelemetry-proto",
+ "opentelemetry-semantic-conventions",
  "opentelemetry_sdk",
  "tokio",
  "tonic",
@@ -2583,13 +2604,15 @@ version = "0.1.0"
 dependencies = [
  "base64",
  "bytes",
+ "const_format",
  "futures",
  "hex",
  "http",
  "linkerd-error",
  "linkerd-http-box",
  "linkerd-stack",
  "linkerd-tracing",
+ "opentelemetry-semantic-conventions",
  "rand 0.9.2",
  "thiserror",
  "tokio",
@@ -2946,6 +2969,12 @@ dependencies = [
  "tonic-prost",
 ]
 
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e62e29dfe041afb8ed2a6c9737ab57db4907285d999ef8ad3a59092a36bdc846"
+
 [[package]]
 name = "opentelemetry_sdk"
 version = "0.31.0"
@@ -4217,6 +4246,12 @@ version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"

linkerd/app/src/trace_collector/otel_collector.rs

@@ -6,6 +6,7 @@ use linkerd_opentelemetry::{
         tonic::common::v1::{any_value, AnyValue, KeyValue},
         transform::common::tonic::ResourceAttributesWithSchema,
     },
+    semconv,
 };
 use std::{
     collections::HashMap,
@@ -42,7 +43,7 @@ where
     resources
         .attributes
         .0
-        .push((std::process::id() as i64).with_key("process.pid"));
+        .push((std::process::id() as i64).with_key(semconv::attribute::PROCESS_PID));
 
     resources.attributes.0.push(
         SystemTime::now()
@@ -55,7 +56,7 @@ where
         attributes
             .hostname
             .unwrap_or_default()
-            .with_key("host.name"),
+            .with_key(semconv::attribute::HOST_NAME),
     );
 
     resources.attributes.0.extend(

linkerd/opentelemetry/Cargo.toml

@@ -15,6 +15,7 @@ linkerd-trace-context = { path = "../trace-context" }
 opentelemetry = { version = "0.31", default-features = false, features = ["trace"] }
 opentelemetry_sdk = { version = "0.31", default-features = false, features = ["trace"] }
 opentelemetry-proto = { version = "0.31" }
+opentelemetry-semantic-conventions = { version = "0.31", features = ["semconv_experimental"] }
 tonic = { workspace = true, default-features = false, features = [
     "codegen",
 ] }

linkerd/opentelemetry/src/lib.rs

@@ -28,6 +28,7 @@ use opentelemetry_proto::{
 };
 use opentelemetry_sdk::trace::{SpanData, SpanLinks};
 pub use opentelemetry_sdk::{self as sdk};
+pub use opentelemetry_semantic_conventions as semconv;
 use tokio::{
     sync::mpsc,
     time::{self, Instant, MissedTickBehavior},

linkerd/trace-context/Cargo.toml

@@ -9,11 +9,13 @@ publish = { workspace = true }
 [dependencies]
 base64 = "0.22"
 bytes = { workspace = true }
+const_format = "0.2"
 futures = { version = "0.3", default-features = false }
 hex = "0.4"
 http = { workspace = true }
 linkerd-error = { path = "../error" }
 linkerd-stack = { path = "../stack" }
+opentelemetry-semantic-conventions = { version = "0.31", default-features = false, features = ["semconv_experimental"] }
 rand = "0.9"
 thiserror = "2"
 tower = { workspace = true, default-features = false, features = ["util"] }

linkerd/trace-context/src/service.rs

@@ -2,6 +2,7 @@ use crate::{propagation, Span, SpanSink};
 use futures::{future::Either, prelude::*};
 use http::Uri;
 use linkerd_stack::layer;
+use opentelemetry_semantic_conventions as semconv;
 use std::{
     collections::HashMap,
     fmt::{Display, Formatter},
@@ -43,21 +44,24 @@ impl<K: Clone, S> TraceContext<K, S> {
     /// https://opentelemetry.io/docs/specs/semconv/http/http-spans/
     fn request_labels<B>(req: &http::Request<B>) -> HashMap<&'static str, String> {
         let mut labels = HashMap::with_capacity(13);
-        labels.insert("http.request.method", format!("{}", req.method()));
+        labels.insert(
+            semconv::trace::HTTP_REQUEST_METHOD,
+            format!("{}", req.method()),
+        );
 
         let url = req.uri();
         if let Some(scheme) = url.scheme_str() {
-            labels.insert("url.scheme", scheme.to_string());
+            labels.insert(semconv::trace::URL_SCHEME, scheme.to_string());
         }
-        labels.insert("url.path", url.path().to_string());
+        labels.insert(semconv::trace::URL_PATH, url.path().to_string());
         if let Some(query) = url.query() {
-            labels.insert("url.query", query.to_string());
+            labels.insert(semconv::trace::URL_QUERY, query.to_string());
         }
 
-        labels.insert("url.full", UrlLabel(url).to_string());
+        labels.insert(semconv::trace::URL_FULL, UrlLabel(url).to_string());
 
         // linkerd currently only proxies tcp-based connections
-        labels.insert("network.transport", "tcp".to_string());
+        labels.insert(semconv::trace::NETWORK_TRANSPORT, "tcp".to_string());
 
         // This is the order of precedence for host headers,
         // see https://opentelemetry.io/docs/specs/semconv/http/http-spans/
@@ -71,10 +75,10 @@ impl<K: Clone, S> TraceContext<K, S> {
             if let Ok(host) = host.to_str() {
                 if let Ok(uri) = host.parse::<Uri>() {
                     if let Some(host) = uri.host() {
-                        labels.insert("server.address", host.to_string());
+                        labels.insert(semconv::trace::SERVER_ADDRESS, host.to_string());
                     }
                     if let Some(port) = uri.port() {
-                        labels.insert("server.port", port.to_string());
+                        labels.insert(semconv::trace::SERVER_PORT, port.to_string());
                     }
                 }
             }
@@ -96,11 +100,20 @@ impl<K: Clone, S> TraceContext<K, S> {
         req: &http::Request<B>,
     ) {
         static HEADER_LABELS: &[(&str, &str)] = &[
-            ("user-agent", "user_agent.original"),
+            ("user-agent", semconv::trace::USER_AGENT_ORIGINAL),
             // http.request.body.size is available as a semantic convention, but is not stable.
-            ("content-length", "http.request.header.content-length"),
-            ("content-type", "http.request.header.content-type"),
-            ("l5d-orig-proto", "http.request.header.l5d-orig-proto"),
+            (
+                "content-length",
+                const_format::concatcp!(semconv::trace::HTTP_REQUEST_HEADER, ".content-length"),
+            ),
+            (
+                "content-type",
+                const_format::concatcp!(semconv::trace::HTTP_REQUEST_HEADER, ".content-type"),
+            ),
+            (
+                "l5d-orig-proto",
+                const_format::concatcp!(semconv::trace::HTTP_REQUEST_HEADER, ".l5d-orig-proto"),
+            ),
         ];
         for &(header, label) in HEADER_LABELS {
             if let Some(value) = req.headers().get(header) {
@@ -114,7 +127,7 @@ impl<K: Clone, S> TraceContext<K, S> {
         rsp: &http::Response<B>,
     ) -> HashMap<&'static str, String> {
         labels.insert(
-            "http.response.status_code",
+            semconv::trace::HTTP_RESPONSE_STATUS_CODE,
             rsp.status().as_str().to_string(),
         );
         labels