More specific types in attributes, removal of case __namespace hack (#9)

* review feedback, accept Int64 in attributes

* more like otel, restrict and dont allow mixed or nested arrays

* wip

* wip

* specific types only allowed in span attrs; remove __namespace hack

* NestedAttributes -> NestedSpanAttributes

* fix swift 5.0

Author: ktoso

Sources/Tracing/Span.swift

@@ -49,18 +49,18 @@ public struct EndUserAttributes: SpanAttributeNamespace {
         self.attributes = attributes
     }
 
-    public struct NestedAttributes: NestedSpanAttributesProtocol {
+    public struct NestedSpanAttributes: NestedSpanAttributesProtocol {
         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> { .init(name: SpanAttributeName.EndUser.id) }
+        public var id: SpanAttribute.Key<String> { .init(name: SpanAttributeName.EndUser.id) }
 
         /// Actual/assumed role the client is making the request under extracted from token or application security context.
-        public var role: SpanAttributeKey<String> { .init(name: SpanAttributeName.EndUser.role) }
+        public var role: SpanAttribute.Key<String> { .init(name: SpanAttributeName.EndUser.role) }
 
         /// 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> { .init(name: SpanAttributeName.EndUser.scope) }
+        public var scope: SpanAttribute.Key<String> { .init(name: SpanAttributeName.EndUser.scope) }
     }
 }
 #endif

Sources/TracingOpenTelemetrySupport/SpanAttribute+EndUser.swift

@@ -51,22 +51,22 @@ public struct GRPCAttributes: SpanAttributeNamespace {
         self.attributes = attributes
     }
 
-    public struct NestedAttributes: NestedSpanAttributesProtocol {
+    public struct NestedSpanAttributes: NestedSpanAttributesProtocol {
         public init() {}
 
         /// The type of message, e.g. "SENT" or "RECEIVED".
-        public var messageType: SpanAttributeKey<String> { .init(name: SpanAttributeName.GRPC.messageType) }
+        public var messageType: SpanAttribute.Key<String> { .init(name: SpanAttributeName.GRPC.messageType) }
 
         /// The message id calculated as two different counters starting from 1, one for sent messages and one for received messages.
-        public var messageID: SpanAttributeKey<Int> { .init(name: SpanAttributeName.GRPC.messageID) }
+        public var messageID: SpanAttribute.Key<Int> { .init(name: SpanAttributeName.GRPC.messageID) }
 
         /// The compressed message size in bytes.
-        public var messageCompressedSize: SpanAttributeKey<Int> {
+        public var messageCompressedSize: SpanAttribute.Key<Int> {
             .init(name: SpanAttributeName.GRPC.messageCompressedSize)
         }
 
         /// The uncompressed message size in bytes.
-        public var messageUncompressedSize: SpanAttributeKey<Int> {
+        public var messageUncompressedSize: SpanAttribute.Key<Int> {
             .init(name: SpanAttributeName.GRPC.messageUncompressedSize)
         }
     }

Sources/TracingOpenTelemetrySupport/SpanAttribute+GRPCSemantics.swift

@@ -75,72 +75,72 @@ public struct HTTPAttributes: SpanAttributeNamespace {
         self.attributes = attributes
     }
 
-    public struct NestedAttributes: NestedSpanAttributesProtocol {
+    public struct NestedSpanAttributes: NestedSpanAttributesProtocol {
         public init() {}
 
         /// HTTP request method. E.g. "GET".
-        public var method: SpanAttributeKey<String> { .init(name: SpanAttributeName.HTTP.method) }
+        public var method: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.method) }
 
         /// 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> { .init(name: SpanAttributeName.HTTP.url) }
+        public var url: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.url) }
 
         /// 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> { .init(name: SpanAttributeName.HTTP.target) }
+        public var target: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.target) }
 
         /// 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> { .init(name: SpanAttributeName.HTTP.host) }
+        public var host: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.host) }
 
         /// The URI scheme identifying the used protocol: "http" or "https"
-        public var scheme: SpanAttributeKey<String> { .init(name: SpanAttributeName.HTTP.scheme) }
+        public var scheme: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.scheme) }
 
         /// HTTP response status code. E.g. 200.
-        public var statusCode: SpanAttributeKey<Int> { .init(name: SpanAttributeName.HTTP.statusCode) }
+        public var statusCode: SpanAttribute.Key<Int> { .init(name: SpanAttributeName.HTTP.statusCode) }
 
         /// HTTP reason phrase. E.g. "OK".
-        public var statusText: SpanAttributeKey<String> { .init(name: SpanAttributeName.HTTP.statusText) }
+        public var statusText: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.statusText) }
 
         /// Kind of HTTP protocol used: "1.0", "1.1", "2", "SPDY" or "QUIC".
-        public var flavor: SpanAttributeKey<String> { .init(name: SpanAttributeName.HTTP.flavor) }
+        public var flavor: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.flavor) }
 
         /// Value of the HTTP User-Agent header sent by the client.
-        public var userAgent: SpanAttributeKey<String> { .init(name: SpanAttributeName.HTTP.userAgent) }
+        public var userAgent: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.userAgent) }
 
         /// 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> {
+        public var requestContentLength: SpanAttribute.Key<Int> {
             .init(name: SpanAttributeName.HTTP.requestContentLength)
         }
 
         /// The size of the uncompressed request payload body after transport decoding. Not set if transport encoding not used.
-        public var requestContentLengthUncompressed: SpanAttributeKey<Int> {
+        public var requestContentLengthUncompressed: SpanAttribute.Key<Int> {
             .init(name: SpanAttributeName.HTTP.requestContentLengthUncompressed)
         }
 
         /// 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> {
+        public var responseContentLength: SpanAttribute.Key<Int> {
             .init(name: SpanAttributeName.HTTP.responseContentLength)
         }
 
         /// The size of the uncompressed response payload body after transport decoding. Not set if transport encoding not used.
-        public var responseContentLengthUncompressed: SpanAttributeKey<Int> {
+        public var responseContentLengthUncompressed: SpanAttribute.Key<Int> {
             .init(name: SpanAttributeName.HTTP.responseContentLengthUncompressed)
         }
 
         /// 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> { .init(name: SpanAttributeName.HTTP.serverName) }
+        public var serverName: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.serverName) }
 
         /// The matched route (path template). E.g. "/users/:userID?".
-        public var serverRoute: SpanAttributeKey<String> { .init(name: SpanAttributeName.HTTP.serverRoute) }
+        public var serverRoute: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.serverRoute) }
 
         /// 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> { .init(name: SpanAttributeName.HTTP.serverClientIP) }
+        public var serverClientIP: SpanAttribute.Key<String> { .init(name: SpanAttributeName.HTTP.serverClientIP) }
     }
 }
 #endif

Sources/TracingOpenTelemetrySupport/SpanAttribute+HTTPSemantics.swift

@@ -57,29 +57,29 @@ public struct NetAttributes: SpanAttributeNamespace {
         self.attributes = attributes
     }
 
-    public struct NestedAttributes: NestedSpanAttributesProtocol {
+    public struct NestedSpanAttributes: NestedSpanAttributesProtocol {
         public init() {}
 
         /// Transport protocol used.
-        public var transport: SpanAttributeKey<String> { .init(name: SpanAttributeName.Net.transport) }
+        public var transport: SpanAttribute.Key<String> { .init(name: SpanAttributeName.Net.transport) }
 
         /// Remote address of the peer (dotted decimal for IPv4 or RFC5952 for IPv6).
-        public var peerIP: SpanAttributeKey<String> { .init(name: SpanAttributeName.Net.peerIP) }
+        public var peerIP: SpanAttribute.Key<String> { .init(name: SpanAttributeName.Net.peerIP) }
 
         /// Remote port number as an integer. E.g., 80.
-        public var peerPort: SpanAttributeKey<Int> { .init(name: SpanAttributeName.Net.peerPort) }
+        public var peerPort: SpanAttribute.Key<Int> { .init(name: SpanAttributeName.Net.peerPort) }
 
         /// Remote hostname or similar.
-        public var peerName: SpanAttributeKey<String> { .init(name: SpanAttributeName.Net.peerName) }
+        public var peerName: SpanAttribute.Key<String> { .init(name: SpanAttributeName.Net.peerName) }
 
         /// Like `peerIP` but for the host IP. Useful in case of a multi-IP host.
-        public var hostIP: SpanAttributeKey<String> { .init(name: SpanAttributeName.Net.hostIP) }
+        public var hostIP: SpanAttribute.Key<String> { .init(name: SpanAttributeName.Net.hostIP) }
 
         /// Like `peerPort` but for the host port.
-        public var hostPort: SpanAttributeKey<Int> { .init(name: SpanAttributeName.Net.hostPort) }
+        public var hostPort: SpanAttribute.Key<Int> { .init(name: SpanAttributeName.Net.hostPort) }
 
         /// Local hostname or similar.
-        public var hostName: SpanAttributeKey<String> { .init(name: SpanAttributeName.Net.hostName) }
+        public var hostName: SpanAttribute.Key<String> { .init(name: SpanAttributeName.Net.hostName) }
     }
 }
 #endif

Sources/TracingOpenTelemetrySupport/SpanAttribute+NetSemantics.swift

@@ -45,11 +45,11 @@ public struct PeerAttributes: SpanAttributeNamespace {
         self.attributes = attributes
     }
 
-    public struct NestedAttributes: NestedSpanAttributesProtocol {
+    public struct NestedSpanAttributes: NestedSpanAttributesProtocol {
         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> { .init(name: SpanAttributeName.Peer.service) }
+        public var service: SpanAttribute.Key<String> { .init(name: SpanAttributeName.Peer.service) }
     }
 }
 #endif

Sources/TracingOpenTelemetrySupport/SpanAttribute+PeerSemantics.swift

@@ -49,17 +49,17 @@ public struct RPCAttributes: SpanAttributeNamespace {
         self.attributes = attributes
     }
 
-    public struct NestedAttributes: NestedSpanAttributesProtocol {
+    public struct NestedSpanAttributes: NestedSpanAttributesProtocol {
         public init() {}
 
         /// A string identifying the remoting system, e.g., "grpc", "java_rmi" or "wcf".
-        public var system: SpanAttributeKey<String> { .init(name: SpanAttributeName.RPC.system) }
+        public var system: SpanAttribute.Key<String> { .init(name: SpanAttributeName.RPC.system) }
 
         /// The full name of the service being called, including its package name, if applicable.
-        public var service: SpanAttributeKey<String> { .init(name: SpanAttributeName.RPC.service) }
+        public var service: SpanAttribute.Key<String> { .init(name: SpanAttributeName.RPC.service) }
 
         /// The name of the method being called, must be equal to the $method part in the span name.
-        public var method: SpanAttributeKey<String> { .init(name: SpanAttributeName.RPC.method) }
+        public var method: SpanAttribute.Key<String> { .init(name: SpanAttributeName.RPC.method) }
     }
 }
 #endif

Sources/TracingOpenTelemetrySupport/SpanAttribute+RPCSemantics.swift

@@ -69,23 +69,12 @@ final class SpanTests: XCTestCase {
     }
 
     func testSpanAttributeIsExpressibleByArrayLiteral() {
-        let attributes: SpanAttribute = [true, "test"]
-        guard case .array(let arrayValue) = attributes else {
-            XCTFail("Expected array attribute, got \(attributes).")
-            return
-        }
-
-        guard case .bool(let boolValue) = arrayValue[0] else {
-            XCTFail("Expected bool attribute, got \(arrayValue[0])")
-            return
-        }
-        XCTAssert(boolValue)
-
-        guard case .string(let stringValue) = arrayValue[1] else {
-            XCTFail("Expected string attribute, got \(arrayValue[1])")
-            return
-        }
-        XCTAssertEqual(stringValue, "test")
+        let s = InstrumentationSystem.tracer.startSpan("", baggage: .topLevel)
+        s.attributes["hi"] = [42, 21]
+        s.attributes["hi"] = [42.10, 21.0]
+        s.attributes["hi"] = [true, false]
+        s.attributes["hi"] = ["one", "two"]
+        s.attributes["hi"] = [1, 2, 34]
     }
 
     func testSpanAttributesUX() {
@@ -99,9 +88,9 @@ final class SpanTests: XCTestCase {
         attributes["bools"] = [true, false, true]
         attributes["alive"] = false
 
-        XCTAssertEqual(attributes["thing.name"], SpanAttribute.string("hello"))
-        XCTAssertEqual(attributes["meaning.of.life"], SpanAttribute.int(42))
-        XCTAssertEqual(attributes["alive"], SpanAttribute.bool(false))
+        XCTAssertEqual(attributes["thing.name"]?.toSpanAttribute(), SpanAttribute.string("hello"))
+        XCTAssertEqual(attributes["meaning.of.life"]?.toSpanAttribute(), SpanAttribute.int(42))
+        XCTAssertEqual(attributes["alive"]?.toSpanAttribute(), SpanAttribute.bool(false))
 
         // using swift 5.2, we can improve upon that by using type-safe, keypath-based subscripts:
         #if swift(>=5.2)
@@ -124,14 +113,18 @@ final class SpanTests: XCTestCase {
         // normally we can use just the span attribute values, and it is not type safe or guided in any way:
         attributes.sampleHttp.customType = CustomAttributeValue()
 
-        XCTAssertEqual(attributes["http.custom_value"], SpanAttribute.stringConvertible(CustomAttributeValue()))
+        XCTAssertEqual(attributes["http.custom_value"]?.toSpanAttribute(), SpanAttribute.stringConvertible(CustomAttributeValue()))
         XCTAssertEqual(String(reflecting: attributes.sampleHttp.customType), "Optional(CustomAttributeValue())")
         XCTAssertEqual(attributes.sampleHttp.customType, CustomAttributeValue())
         #endif
     }
 
     func testSpanAttributesAreIterable() {
-        let attributes: SpanAttributes = ["0": 0, "1": true, "2": "test"]
+        let attributes: SpanAttributes = [
+            "0": 0,
+            "1": true,
+            "2": "test",
+        ]
 
         var dictionary = [String: SpanAttribute]()
         attributes.forEach { name, attribute in
@@ -176,21 +169,20 @@ final class SpanTests: XCTestCase {
         XCTAssertEqual(child.links[0].baggage[TestBaggageContextKey.self], "test")
         #if swift(>=5.2)
         XCTAssertEqual(child.links[0].attributes.sampleHttp.statusCode, 418)
-        #else
-        guard case .some(.int(let statusCode)) = child.links[0].attributes["http.status_code"] else {
+        #endif
+        guard case .some(.int(let statusCode)) = child.links[0].attributes["http.status_code"]?.toSpanAttribute() else {
             XCTFail("Expected int value for http.status_code")
             return
         }
         XCTAssertEqual(statusCode, 418)
-        #endif
     }
 }
 
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: Example Span attributes
 
 extension SpanAttribute {
-    var name: SpanAttributeKey<String> {
+    var name: Key<String> {
         return "name"
     }
 }
@@ -214,18 +206,18 @@ public struct HTTPAttributes: SpanAttributeNamespace {
         self.attributes = attributes
     }
 
-    public struct NestedAttributes: NestedSpanAttributesProtocol {
+    public struct NestedSpanAttributes: NestedSpanAttributesProtocol {
         public init() {}
 
-        public var statusCode: SpanAttributeKey<Int> {
+        public var statusCode: SpanAttribute.Key<Int> {
             "http.status_code"
         }
 
-        public var codesArray: SpanAttributeKey<[Int]> {
+        public var codesArray: SpanAttribute.Key<[Int]> {
             "http.codes_array"
         }
 
-        public var customType: SpanAttributeKey<CustomAttributeValue> {
+        public var customType: SpanAttribute.Key<CustomAttributeValue> {
             "http.custom_value"
         }
     }

Tests/TracingTests/SpanTests.swift

@@ -99,7 +99,7 @@ struct FakeHTTPServer {
         let span = tracer.startSpan("GET \(request.path)", baggage: baggage)
 
         let response = self.catchAllHandler(span.baggage, request, self.client)
-        span.attributes["http.status"] = .int(response.status)
+        span.attributes["http.status"] = response.status
 
         span.end()
     }