Add SpanAttributeName String constants

Author: slashmo

Sources/OpenTelemetryInstrumentationSupport/SpanAttribute+EndUser.swift

@@ -11,9 +11,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if swift(>=5.2)
 import TracingInstrumentation
 
+extension SpanAttributeName {
+    public static let endUserID = "enduser.id"
+    public static let endUserRole = "enduser.role"
+    public static let endUserScope = "enduser.scope"
+}
+
+#if swift(>=5.2)
 extension SpanAttributes {
     /// Semantic end-user attributes.
     public var endUser: EndUserAttributes {
@@ -39,14 +45,14 @@ public struct EndUserAttributes: SpanAttributeNamespace {
         public init() {}
 
         /// Username or client_id extracted from the access token or Authorization header in the inbound request from outside the system.
-        public var id: SpanAttributeKey<String> { "enduser.id" }
+        public var id: SpanAttributeKey<String> { .init(name: SpanAttributeName.endUserID) }
 
         /// Actual/assumed role the client is making the request under extracted from token or application security context.
-        public var role: SpanAttributeKey<String> { "enduser.role" }
+        public var role: SpanAttributeKey<String> { .init(name: SpanAttributeName.endUserRole) }
 
         /// Scopes or granted authorities the client currently possesses extracted from token or application security context.
         /// The value would come from the scope associated with an OAuth 2.0 Access Token or an attribute value in a SAML 2.0 Assertion.
-        public var scope: SpanAttributeKey<String> { "enduser.scope" }
+        public var scope: SpanAttributeKey<String> { .init(name: SpanAttributeName.endUserScope) }
     }
 }
 #endif

Sources/OpenTelemetryInstrumentationSupport/SpanAttribute+HTTPSemantics.swift

@@ -11,9 +11,28 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if swift(>=5.2)
 import TracingInstrumentation
 
+extension SpanAttributeName {
+    public static let httpMethod = "http.method"
+    public static let httpURL = "http.url"
+    public static let httpTarget = "http.target"
+    public static let httpHost = "http.host"
+    public static let httpScheme = "http.scheme"
+    public static let httpStatusCode = "http.status_code"
+    public static let httpStatusText = "http.status_text"
+    public static let httpFlavor = "http.flavor"
+    public static let httpUserAgent = "http.user_agent"
+    public static let httpRequestContentLength = "http.request_content_length"
+    public static let httpRequestContentLengthUncompressed = "http.request_content_length_uncompressed"
+    public static let httpResponseContentLength = "http.response_content_length"
+    public static let httpResponseContentLengthUncompressed = "http.response_content_length_uncompressed"
+    public static let httpServerName = "http.server_name"
+    public static let httpServerRoute = "http.route"
+    public static let httpServerClientIP = "http.client_ip"
+}
+
+#if swift(>=5.2)
 extension SpanAttributes {
     /// Semantic conventions for HTTP spans.
     public var http: HTTPAttributes {
@@ -39,64 +58,68 @@ public struct HTTPAttributes: SpanAttributeNamespace {
         public init() {}
 
         /// HTTP request method. E.g. "GET".
-        public var method: SpanAttributeKey<String> { "http.method" }
+        public var method: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpMethod) }
 
         /// Full HTTP request URL in the form scheme://host[:port]/path?query[#fragment].
         /// Usually the fragment is not transmitted over HTTP, but if it is known, it should be included nevertheless.
-        public var url: SpanAttributeKey<String> { "http.url" }
+        public var url: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpURL) }
 
         /// The full request target as passed in a HTTP request line or equivalent, e.g. "/path/12314/?q=ddds#123".
-        public var target: SpanAttributeKey<String> { "http.target" }
+        public var target: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpTarget) }
 
         /// The value of the HTTP host header. When the header is empty or not present, this attribute should be the same.
-        public var host: SpanAttributeKey<String> { "http.host" }
+        public var host: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpHost) }
 
         /// The URI scheme identifying the used protocol: "http" or "https"
-        public var scheme: SpanAttributeKey<String> { "http.scheme" }
+        public var scheme: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpScheme) }
 
         /// HTTP response status code. E.g. 200.
-        public var statusCode: SpanAttributeKey<Int> { "http.status_code" }
+        public var statusCode: SpanAttributeKey<Int> { .init(name: SpanAttributeName.httpStatusCode) }
 
         /// HTTP reason phrase. E.g. "OK".
-        public var statusText: SpanAttributeKey<String> { "http.status_text" }
+        public var statusText: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpStatusText) }
 
         /// Kind of HTTP protocol used: "1.0", "1.1", "2", "SPDY" or "QUIC".
-        public var flavor: SpanAttributeKey<String> { "http.flavor" }
+        public var flavor: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpFlavor) }
 
         /// Value of the HTTP User-Agent header sent by the client.
-        public var userAgent: SpanAttributeKey<String> { "http.user_agent" }
+        public var userAgent: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpUserAgent) }
 
         /// The size of the request payload body in bytes. This is the number of bytes transferred excluding headers and is often,
         /// but not always, present as the Content-Length header. For requests using transport encoding, this should be the
         /// compressed size.
-        public var requestContentLength: SpanAttributeKey<Int> { "http.request_content_length" }
+        public var requestContentLength: SpanAttributeKey<Int> {
+            .init(name: SpanAttributeName.httpRequestContentLength)
+        }
 
         /// The size of the uncompressed request payload body after transport decoding. Not set if transport encoding not used.
         public var requestContentLengthUncompressed: SpanAttributeKey<Int> {
-            "http.request_content_length_uncompressed"
+            .init(name: SpanAttributeName.httpRequestContentLengthUncompressed)
         }
 
         /// The size of the response payload body in bytes. This is the number of bytes transferred excluding headers and
         /// is often, but not always, present as the Content-Length header. For requests using transport encoding, this
         /// should be the compressed size.
-        public var responseContentLength: SpanAttributeKey<Int> { "http.response_content_length" }
+        public var responseContentLength: SpanAttributeKey<Int> {
+            .init(name: SpanAttributeName.httpResponseContentLength)
+        }
 
         /// The size of the uncompressed response payload body after transport decoding. Not set if transport encoding not used.
         public var responseContentLengthUncompressed: SpanAttributeKey<Int> {
-            "http.response_content_length_uncompressed"
+            .init(name: SpanAttributeName.httpResponseContentLengthUncompressed)
         }
 
         /// The primary server name of the matched virtual host. This should be obtained via configuration.
         /// If no such configuration can be obtained, this attribute MUST NOT be set (`net.hostName` should be used instead).
-        public var serverName: SpanAttributeKey<String> { "http.server_name" }
+        public var serverName: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpServerName) }
 
         /// The matched route (path template). E.g. "/users/:userID?".
-        public var serverRoute: SpanAttributeKey<String> { "http.route" }
+        public var serverRoute: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpServerRoute) }
 
         /// The IP address of the original client behind all proxies, if known (e.g. from X-Forwarded-For).
         /// Note that this is not necessarily the same as `net.peerIP`, which would identify the network-level peer,
         /// which may be a proxy.
-        public var serverClientIP: SpanAttributeKey<String> { "http.client_ip" }
+        public var serverClientIP: SpanAttributeKey<String> { .init(name: SpanAttributeName.httpServerClientIP) }
     }
 }
 #endif

Sources/OpenTelemetryInstrumentationSupport/SpanAttribute+NetSemantics.swift

@@ -11,9 +11,19 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if swift(>=5.2)
 import TracingInstrumentation
 
+extension SpanAttributeName {
+    public static let netTransport = "net.transport"
+    public static let netPeerIP = "net.peer.ip"
+    public static let netPeerPort = "net.peer.port"
+    public static let netPeerName = "net.peer.name"
+    public static let netHostIP = "net.host.ip"
+    public static let netHostPort = "net.host.port"
+    public static let netHostName = "net.host.name"
+}
+
+#if swift(>=5.2)
 extension SpanAttributes {
     /// Semantic network attributes.
     public var net: NetAttributes {
@@ -39,25 +49,25 @@ public struct NetAttributes: SpanAttributeNamespace {
         public init() {}
 
         /// Transport protocol used.
-        public var transport: SpanAttributeKey<String> { "net.transport" }
+        public var transport: SpanAttributeKey<String> { .init(name: SpanAttributeName.netTransport) }
 
         /// Remote address of the peer (dotted decimal for IPv4 or RFC5952 for IPv6).
-        public var peerIP: SpanAttributeKey<String> { "net.peer.ip" }
+        public var peerIP: SpanAttributeKey<String> { .init(name: SpanAttributeName.netPeerIP) }
 
         /// Remote port number as an integer. E.g., 80.
-        public var peerPort: SpanAttributeKey<Int> { "net.peer.port" }
+        public var peerPort: SpanAttributeKey<Int> { .init(name: SpanAttributeName.netPeerPort) }
 
         /// Remote hostname or similar.
-        public var peerName: SpanAttributeKey<String> { "net.peer.name" }
+        public var peerName: SpanAttributeKey<String> { .init(name: SpanAttributeName.netPeerName) }
 
         /// Like `peerIP` but for the host IP. Useful in case of a multi-IP host.
-        public var hostIP: SpanAttributeKey<String> { "net.host.ip" }
+        public var hostIP: SpanAttributeKey<String> { .init(name: SpanAttributeName.netHostIP) }
 
         /// Like `peerPort` but for the host port.
-        public var hostPort: SpanAttributeKey<Int> { "net.host.port" }
+        public var hostPort: SpanAttributeKey<Int> { .init(name: SpanAttributeName.netHostPort) }
 
         /// Local hostname or similar.
-        public var hostName: SpanAttributeKey<String> { "net.host.name" }
+        public var hostName: SpanAttributeKey<String> { .init(name: SpanAttributeName.netHostName) }
     }
 }
 #endif

Sources/OpenTelemetryInstrumentationSupport/SpanAttribute+PeerSemantics.swift

@@ -11,9 +11,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if swift(>=5.2)
 import TracingInstrumentation
 
+extension SpanAttributeName {
+    public static let peerService = "peer.service"
+}
+
+#if swift(>=5.2)
 extension SpanAttributes {
     /// General semantic attributes.
     public var peer: PeerAttributes {
@@ -39,7 +43,7 @@ public struct PeerAttributes: SpanAttributeNamespace {
         public init() {}
 
         /// The service.name of the remote service. SHOULD be equal to the actual service.name resource attribute of the remote service if any.
-        public var service: SpanAttributeKey<String> { "peer.service" }
+        public var service: SpanAttributeKey<String> { .init(name: SpanAttributeName.peerService) }
     }
 }
 #endif

Sources/OpenTelemetryInstrumentationSupport/SpanAttributeName.swift

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift Distributed Tracing open source project
+//
+// Copyright (c) 2020 Moritz Lang and the Swift Tracing project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import TracingInstrumentation
+
+/// A set of `String` constants describing semantic names for `SpanAttributes`.
+public enum SpanAttributeName {}