feat: make header and body capture feature GA & fix bug for allowlist rule (#396)

* feat: make header and body capture feature GA & fix bug for allowlist rule

* chore: remove Package.resolved and fix deprecated init ambiguity

Add Package.resolved to .gitignore (library packages should not pin
resolved versions). Remove default value from deprecated blocklist
parameter to avoid overload ambiguity with the new excludelist init.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* update

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sojingle

.gitignore

@@ -7,3 +7,4 @@ DerivedData/
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 .netrc
 node_modules/
+Package.resolved

Examples/AmplitudeSwiftUIExample/AmplitudeSwiftUIExample/AmplitudeSwiftUIExampleApp.swift

@@ -5,7 +5,6 @@
 //  Created by Hao Yu on 11/30/22.
 //
 
-@_spi(NetworkTracking)
 import AmplitudeSwift
 import AppTrackingTransparency
 import Experiment

Sources/Amplitude/Plugins/NetworkTrackingPlugin.swift

@@ -83,16 +83,17 @@ public struct NetworkTrackingOptions {
 
     public struct CaptureBody: Decodable {
         public let allowlist: [String]
-        public let blocklist: [String]
+        public let excludelist: [String]
 
-        public init(allowlist: [String], blocklist: [String] = []) {
+        public init(allowlist: [String], excludelist: [String] = []) {
             self.allowlist = allowlist
-            self.blocklist = blocklist
+            self.excludelist = excludelist
         }
 
-        enum CodingKeys: String, CodingKey {
-            case allowlist
-            case blocklist = "excludelist"
+        @available(*, deprecated, renamed: "init(allowlist:excludelist:)", message: "Deprecated, use 'excludelist' instead")
+        public init(allowlist: [String], blocklist: [String]) {
+            self.allowlist = allowlist
+            self.excludelist = blocklist
         }
     }
 
@@ -155,7 +156,6 @@ public struct NetworkTrackingOptions {
             self.responseBody = nil
         }
 
-        @_spi(NetworkTracking)
         public init(urls: [URLPattern],
                     methods: [String] = ["*"],
                     statusCodeRange: String = "500-599",
@@ -561,7 +561,7 @@ class CompiledNetworkTrackingOptions {
         let objectFilter: ObjectFilter
 
         init(body: NetworkTrackingOptions.CaptureBody) {
-            self.objectFilter = ObjectFilter(allowList: body.allowlist, blockList: body.blocklist)
+            self.objectFilter = ObjectFilter(allowList: body.allowlist, blockList: body.excludelist)
         }
 
         func filterBody(_ body: Any) -> Any? {

Sources/Amplitude/Utilities/ObjectFilter.swift

@@ -74,13 +74,6 @@ class ObjectFilter {
             return isAllowed(path) ? value : nil
         }
 
-        // Return entire container for exact non-wildcard matches
-        if allowKeyPaths.contains(where: {
-            !$0.contains { $0 == "*" || $0 == "**" } && matches(path, $0) && !isBlocked(path)
-        }) {
-            return value
-        }
-
         // Return empty containers that match patterns
         if isAllowed(path) {
             if let dict = value as? [String: Any], dict.isEmpty { return value }
@@ -115,7 +108,13 @@ class ObjectFilter {
     }
 
     private func canMatchDescendants(_ path: KeyPath, _ pattern: KeyPath) -> Bool {
-        guard pattern.count > path.count else { return pattern.contains("**") }
+        guard pattern.count > path.count else {
+            for i in 0..<pattern.count {
+                if pattern[i] == "**" { return true }
+                if pattern[i] != path[i] && pattern[i] != "*" { return false }
+            }
+            return false
+        }
 
         for i in 0..<path.count {
             if pattern[i] == "**" { return true }

Tests/AmplitudeTests/AutocaptureRemoteConfigTests.swift

@@ -524,11 +524,11 @@ class AutocaptureRemoteConfigTests: XCTestCase {
             // Verify body configuration
             XCTAssertNotNil(captureRule.requestBody)
             XCTAssertEqual(captureRule.requestBody?.allowlist, ["userId", "eventType"])
-            XCTAssertEqual(captureRule.requestBody?.blocklist, ["password", "token"])
+            XCTAssertEqual(captureRule.requestBody?.excludelist, ["password", "token"])
 
             XCTAssertNotNil(captureRule.responseBody)
             XCTAssertEqual(captureRule.responseBody?.allowlist, ["status", "message"])
-            XCTAssertEqual(captureRule.responseBody?.blocklist, ["secret"])
+            XCTAssertEqual(captureRule.responseBody?.excludelist, ["secret"])
         }
     }
 

Tests/AmplitudeTests/Plugins/NetworkTrackingPluginTest.swift

@@ -7,7 +7,6 @@
 
 import XCTest
 
-@_spi(NetworkTracking)
 @testable import AmplitudeSwift
 
 // swiftlint:disable force_cast
@@ -1062,8 +1061,8 @@ final class NetworkTrackingPluginTest: XCTestCase {
                     responseHeaders: NetworkTrackingOptions.CaptureHeader(),
                     requestBody: nil,  // GET requests typically don't have body
                     responseBody: NetworkTrackingOptions.CaptureBody(
-                        allowlist: ["products", "total"],
-                        blocklist: ["internal_metadata"]
+                        allowlist: ["products/**", "total"],
+                        excludelist: ["internal_metadata"]
                     )
                 )
             ]

Tests/AmplitudeTests/Utilities/ObjectFilterTests.swift

@@ -540,7 +540,7 @@ final class ObjectFilterTests: XCTestCase {
 
     func testFilterdWithArray() throws {
         // Test array filtering with index
-        let filter = ObjectFilter(allowList: ["users/0", "users/1/name"])
+        let filter = ObjectFilter(allowList: ["users/0/**", "users/1/name"])
 
         let input: [String: Any] = [
             "users": [
@@ -566,7 +566,7 @@ final class ObjectFilterTests: XCTestCase {
     }
 
     func testFilterdArrayAtRoot() throws {
-        let filter = ObjectFilter(allowList: ["0/name", "1"])
+        let filter = ObjectFilter(allowList: ["0/name", "1/**"])
 
         let input: [Any] = [
             ["name": "John", "email": "john@example.com"],
@@ -707,6 +707,69 @@ final class ObjectFilterTests: XCTestCase {
         XCTAssertNil(result3)
     }
 
+    func testExactMatchOnPrimitiveIsCaptured() throws {
+        let filter = ObjectFilter(allowList: ["name"])
+        let input: [String: Any] = ["name": "John", "age": 30]
+        let result = filter.filterd(input) as? [String: Any]
+        XCTAssertNotNil(result)
+        XCTAssertEqual(result?["name"] as? String, "John")
+        XCTAssertNil(result?["age"])
+    }
+
+    func testExactMatchOnContainerIsNotCaptured() throws {
+        let filter = ObjectFilter(allowList: ["user"])
+        let input: [String: Any] = ["user": ["name": "John", "password": "secret"]]
+        // "user" is a container — exact match without wildcard should not return it
+        XCTAssertNil(filter.filterd(input))
+    }
+
+    func testExactMatchOnContainerVsWildcard() throws {
+        let input: [String: Any] = ["user": ["name": "John", "password": "secret"] as [String: Any]]
+
+        // "user" alone does not capture the object
+        let filter1 = ObjectFilter(allowList: ["user"])
+        XCTAssertNil(filter1.filterd(input))
+
+        // "user/**" captures the full object
+        let filter2 = ObjectFilter(allowList: ["user/**"])
+        let result2 = filter2.filterd(input) as? [String: Any]
+        let user2 = result2?["user"] as? [String: Any]
+        XCTAssertEqual(user2?["name"] as? String, "John")
+        XCTAssertEqual(user2?["password"] as? String, "secret")
+
+        // "user/*" captures direct children
+        let filter3 = ObjectFilter(allowList: ["user/*"])
+        let result3 = filter3.filterd(input) as? [String: Any]
+        let user3 = result3?["user"] as? [String: Any]
+        XCTAssertEqual(user3?["name"] as? String, "John")
+        XCTAssertEqual(user3?["password"] as? String, "secret")
+    }
+
+    func testExactMatchWithBlocklistOnDescendants() throws {
+        let filter = ObjectFilter(allowList: ["user/**"], blockList: ["user/password"])
+        let input: [String: Any] = ["user": ["name": "John", "password": "secret"] as [String: Any]]
+        let result = filter.filterd(input) as? [String: Any]
+        let user = result?["user"] as? [String: Any]
+        XCTAssertEqual(user?["name"] as? String, "John")
+        XCTAssertNil(user?["password"])
+    }
+
+    func testExactMatchOnArrayIsNotCaptured() throws {
+        let filter = ObjectFilter(allowList: ["items"])
+        let input: [String: Any] = ["items": ["a", "b", "c"]]
+        XCTAssertNil(filter.filterd(input))
+    }
+
+    func testDoesNotDescendIntoMismatchedPrefixWithDoubleWildcard() throws {
+        let filter = ObjectFilter(allowList: ["c/**"])
+        let input: [String: Any] = [
+            "a": [
+                "nested": ["value": "ignored"] as [String: Any]
+            ] as [String: Any]
+        ]
+        XCTAssertNil(filter.filterd(input))
+    }
+
     func testFilterdNilInput() throws {
         let filter = ObjectFilter(allowList: ["user"])