feat: add engine-free request metrics policy

Author: coenttb

Package.swift

@@ -0,0 +1,36 @@
+// swift-tools-version: 6.3.3
+
+import PackageDescription
+
+let package = Package(
+    name: "swift-metrics",
+    platforms: [
+        .macOS(.v26),
+        .iOS(.v26),
+        .tvOS(.v26),
+        .watchOS(.v26),
+        .visionOS(.v26),
+    ],
+    products: [
+        .library(name: "Metrics", targets: ["Metrics"]),
+    ],
+    targets: [
+        .target(name: "Metrics"),
+        .testTarget(name: "Metrics Tests", dependencies: ["Metrics"]),
+    ],
+    swiftLanguageModes: [.v6]
+)
+
+for target in package.targets where ![.system, .binary, .plugin, .macro].contains(target.type) {
+    target.swiftSettings = [
+        .strictMemorySafety(),
+        .enableUpcomingFeature("ExistentialAny"),
+        .enableUpcomingFeature("InternalImportsByDefault"),
+        .enableUpcomingFeature("MemberImportVisibility"),
+        .enableUpcomingFeature("NonisolatedNonsendingByDefault"),
+        .enableExperimentalFeature("LifetimeDependence"),
+        .enableExperimentalFeature("Lifetimes"),
+        .enableExperimentalFeature("SuppressedAssociatedTypes"),
+        .enableUpcomingFeature("InferIsolatedConformances"),
+    ]
+}

Sources/Metrics/Metrics.Request.Event.Severity.swift

@@ -0,0 +1,9 @@
+extension Metrics.Request.Event {
+    /// Adapter-neutral importance assigned by the request policy.
+    public enum Severity: Equatable, Sendable {
+        case trace
+        case info
+        case warning
+        case error
+    }
+}

Sources/Metrics/Metrics.Request.Event.swift

@@ -0,0 +1,24 @@
+extension Metrics.Request {
+    /// The canonical event emitted for a completed request.
+    public struct Event: Equatable, Sendable {
+        public let name: String
+        public let method: String
+        public let path: String
+        public let statusCode: Int
+        public let duration: Duration
+        public let requestID: String?
+        public let isStaticFile: Bool
+        public let severity: Severity
+
+        internal init(request: Metrics.Request, severity: Severity, isStaticFile: Bool) {
+            self.name = "http.request"
+            self.method = request.method
+            self.path = request.path
+            self.statusCode = request.statusCode
+            self.duration = request.duration
+            self.requestID = request.requestID
+            self.isStaticFile = isStaticFile
+            self.severity = severity
+        }
+    }
+}

Sources/Metrics/Metrics.Request.Policy.swift

@@ -0,0 +1,58 @@
+extension Metrics.Request {
+    /// Pure policy for turning completed request facts into one metrics event.
+    public struct Policy: Sendable {
+        public let detectStaticFiles: Bool
+
+        public init(detectStaticFiles: Bool = true) {
+            self.detectStaticFiles = detectStaticFiles
+        }
+
+        public func event(for request: Metrics.Request) -> Event {
+            let isStaticFile = detectStaticFiles && Self.isStaticFile(request)
+            return Event(
+                request: request,
+                severity: Self.severity(for: request.statusCode, isStaticFile: isStaticFile),
+                isStaticFile: isStaticFile
+            )
+        }
+
+        private static func severity(
+            for statusCode: Int,
+            isStaticFile: Bool
+        ) -> Event.Severity {
+            if isStaticFile || statusCode == 304 {
+                return .trace
+            }
+            switch statusCode {
+            case 500...:
+                return .error
+
+            case 400..<500:
+                return .warning
+
+            default:
+                return .info
+            }
+        }
+
+        private static func isStaticFile(_ request: Metrics.Request) -> Bool {
+            guard request.method == "GET" || request.method == "HEAD" else { return false }
+            guard request.statusCode == 200 || request.statusCode == 304 else { return false }
+
+            if let contentType = request.contentType {
+                let staticContentTypes = [
+                    "image/", "text/css", "application/javascript", "font/", "video/", "audio/",
+                ]
+                if staticContentTypes.contains(where: contentType.hasPrefix) {
+                    return true
+                }
+            }
+
+            let staticExtensions = [
+                ".css", ".js", ".jpg", ".jpeg", ".png", ".gif", ".svg", ".ico",
+                ".woff", ".woff2", ".ttf",
+            ]
+            return staticExtensions.contains(where: request.path.hasSuffix)
+        }
+    }
+}

Sources/Metrics/Metrics.Request.swift

@@ -0,0 +1,27 @@
+extension Metrics {
+    /// The adapter-neutral facts available when a request has completed.
+    public struct Request: Equatable, Sendable {
+        public let method: String
+        public let path: String
+        public let statusCode: Int
+        public let duration: Duration
+        public let requestID: String?
+        public let contentType: String?
+
+        public init(
+            method: String,
+            path: String,
+            statusCode: Int,
+            duration: Duration,
+            requestID: String? = nil,
+            contentType: String? = nil
+        ) {
+            self.method = method
+            self.path = path
+            self.statusCode = statusCode
+            self.duration = duration
+            self.requestID = requestID
+            self.contentType = contentType
+        }
+    }
+}

Sources/Metrics/Metrics.swift

@@ -0,0 +1,3 @@
+/// Engine-free measurement and event policy for application metrics.
+public enum Metrics {
+}

Tests/Metrics Tests/Metrics.Request.Policy Tests.swift

@@ -0,0 +1,71 @@
+import Testing
+
+@testable import Metrics
+
+@Suite("Request metrics policy")
+struct RequestPolicyTests {
+    @Test("emits the canonical request event")
+    func event() {
+        let request = Metrics.Request(
+            method: "GET",
+            path: "/assets/app.js",
+            statusCode: 200,
+            duration: .milliseconds(42),
+            requestID: "abc",
+            contentType: "application/javascript"
+        )
+
+        let event = Metrics.Request.Policy().event(for: request)
+
+        #expect(event.name == "http.request")
+        #expect(event.method == "GET")
+        #expect(event.path == "/assets/app.js")
+        #expect(event.statusCode == 200)
+        #expect(event.duration == .milliseconds(42))
+        #expect(event.requestID == "abc")
+        #expect(event.isStaticFile)
+        #expect(event.severity == .trace)
+    }
+
+    @Test("classifies response status without an engine")
+    func severity() {
+        let policy = Metrics.Request.Policy(detectStaticFiles: false)
+
+        #expect(policy.event(for: request(statusCode: 304)).severity == .trace)
+        #expect(policy.event(for: request(statusCode: 404)).severity == .warning)
+        #expect(policy.event(for: request(statusCode: 503)).severity == .error)
+        #expect(policy.event(for: request(statusCode: 201)).severity == .info)
+    }
+
+    @Test("uses the extension fallback for static files")
+    func staticFileExtensionFallback() {
+        let request = Metrics.Request(
+            method: "HEAD",
+            path: "/assets/site.css",
+            statusCode: 304,
+            duration: .zero
+        )
+
+        let event = Metrics.Request.Policy().event(for: request)
+
+        #expect(event.isStaticFile)
+        #expect(event.severity == .trace)
+    }
+
+    @Test("does not classify non-GET requests as static files")
+    func staticFileMethodGuard() {
+        let request = Metrics.Request(
+            method: "POST",
+            path: "/assets/site.css",
+            statusCode: 200,
+            duration: .zero,
+            contentType: "text/css"
+        )
+
+        #expect(!Metrics.Request.Policy().event(for: request).isStaticFile)
+    }
+
+    private func request(statusCode: Int) -> Metrics.Request {
+        Metrics.Request(method: "GET", path: "/", statusCode: statusCode, duration: .milliseconds(1))
+    }
+}