Add SDKConfigBenchmark: legacy vs config endpoint benchmark suite

.gitignore

@@ -107,3 +107,7 @@ Tests/TestingApps/PaywallsTester/PaywallsTester/PaywallsTester.storekit
 
 # Claude Code
 .claude/
+
+# Python bytecode (e.g. from running the benchmark compare.py)
+__pycache__/
+*.pyc

Dangerfile

@@ -4,7 +4,11 @@ require 'pathname'
 require 'set'
 
 EXCLUDED_SWIFT_PATH_PREFIXES = [
-  'Tests/APITesters/'
+  'Tests/APITesters/',
+  # Tuist-only benchmark targets (Projects/SDKConfigBenchmark and
+  # Projects/SDKConfigBenchmarkApp); intentionally absent from RevenueCat.xcodeproj.
+  'Tests/Benchmarks/',
+  'Tests/TestingApps/SDKConfigBenchmarkApp/'
 ].freeze
 
 COMMENT_MARKER = "<!-- purchases-ios-danger -->"

Projects/SDKConfigBenchmark/Project.swift

@@ -0,0 +1,104 @@
+import ProjectDescription
+import ProjectDescriptionHelpers
+
+// Benchmark harness for comparing the legacy offerings flow against the remote config
+// endpoint flow. Compiles the SDK sources directly (like BinarySizeTest does for its
+// local-source mode) so the benchmark can drive internal manager-level APIs without
+// exposing new public SDK API. `SDK_CONFIG_BENCHMARK` installs a simulated transport
+// in `HTTPClient`; `ENABLE_REMOTE_CONFIG` turns on the remote config gate.
+//
+// TUIST_SWIFT_CONDITIONS is folded in by hand instead of via
+// `appendingTuistSwiftConditions()`, because that helper replaces the whole
+// SWIFT_ACTIVE_COMPILATION_CONDITIONS value and would silently drop the benchmark flags.
+let benchmarkSwiftConditions: SettingsDictionary = [
+    "SWIFT_ACTIVE_COMPILATION_CONDITIONS": SettingValue(stringLiteral: (
+        ["$(inherited)", "SDK_CONFIG_BENCHMARK", "ENABLE_REMOTE_CONFIG"] + Environment.extraSwiftConditions
+    ).joined(separator: " "))
+]
+
+let project = Project(
+    name: "SDKConfigBenchmark",
+    organizationName: .revenueCatOrgName,
+    settings: .framework,
+    targets: [
+        .target(
+            name: "SDKConfigBenchmarkCore",
+            destinations: [.mac],
+            product: .staticLibrary,
+            bundleId: "com.revenuecat.SDKConfigBenchmarkCore",
+            deploymentTargets: .macOS("13.0"),
+            infoPlist: .default,
+            sources: [
+                "../../Tests/Benchmarks/SDKConfigBenchmark/Sources/**/*.swift",
+                .glob(
+                    "../../Sources/**/*.swift",
+                    excluding: [
+                        "../../Sources/LocalReceiptParsing/ReceiptParser-only-files/**/*.swift"
+                    ]
+                )
+            ],
+            dependencies: [
+                .storeKit
+            ],
+            settings: .settings(
+                base: benchmarkSwiftConditions
+            )
+        ),
+        .target(
+            name: "SDKConfigBenchmark",
+            destinations: [.mac],
+            product: .commandLineTool,
+            bundleId: "com.revenuecat.SDKConfigBenchmark",
+            deploymentTargets: .macOS("13.0"),
+            infoPlist: .default,
+            sources: [
+                "../../Tests/Benchmarks/SDKConfigBenchmark/Main/**/*.swift"
+            ],
+            dependencies: [
+                .target(name: "SDKConfigBenchmarkCore")
+            ],
+            settings: .settings(
+                // The SDK's disk caches derive their directory from Bundle.main.bundleIdentifier,
+                // which a bare command-line binary does not have. Embedding the Info.plist into
+                // the binary gives it one, so etags/offerings/remote-config persistence works.
+                base: benchmarkSwiftConditions
+                    .merging(["CREATE_INFOPLIST_SECTION_IN_BINARY": "YES"])
+            )
+        ),
+        .target(
+            name: "SDKConfigBenchmarkTests",
+            destinations: [.mac],
+            product: .unitTests,
+            bundleId: "com.revenuecat.SDKConfigBenchmarkTests",
+            deploymentTargets: .macOS("13.0"),
+            infoPlist: .default,
+            sources: [
+                "../../Tests/Benchmarks/SDKConfigBenchmark/Tests/**/*.swift",
+                // App-host tier helpers, shared into this target so their aggregation
+                // logic is unit-testable without booting a simulator.
+                "../../Tests/TestingApps/SDKConfigBenchmarkApp/App/LaunchMeasurement.swift",
+                "../../Tests/TestingApps/SDKConfigBenchmarkApp/UITests/AppLaunchMetrics.swift"
+            ],
+            dependencies: [
+                .target(name: "SDKConfigBenchmarkCore")
+            ],
+            settings: .settings(
+                base: benchmarkSwiftConditions
+            )
+        )
+    ],
+    schemes: [
+        .scheme(
+            name: "SDKConfigBenchmark",
+            shared: true,
+            buildAction: .buildAction(targets: ["SDKConfigBenchmark"]),
+            runAction: .runAction(configuration: "Release")
+        ),
+        .scheme(
+            name: "SDKConfigBenchmarkTests",
+            shared: true,
+            buildAction: .buildAction(targets: ["SDKConfigBenchmarkTests"]),
+            testAction: .targets(["SDKConfigBenchmarkTests"])
+        )
+    ]
+)

Projects/SDKConfigBenchmarkApp/Project.swift

@@ -0,0 +1,85 @@
+import ProjectDescription
+import ProjectDescriptionHelpers
+
+// App-host tier of the SDK config benchmark: a minimal iOS app that links the stock
+// RevenueCat/RevenueCatUI products (unlike Projects/SDKConfigBenchmark, which compiles the
+// SDK sources directly) and measures a real `Purchases.configure` launch end to end.
+// Local/CI only; driven by Tests/TestingApps/SDKConfigBenchmarkApp/run-app-launch.sh.
+//
+// The legacy-vs-config variant switch is NOT set here: the SPM-built RevenueCat reads
+// `SWIFT_ACTIVE_COMPILATION_CONDITIONS` from Local.xcconfig (see Package.swift), which the
+// runner script rewrites per variant.
+
+// Injected into the scheme's run environment so the app can be launched straight from Xcode:
+//   TUIST_BENCH_API_KEY=<key> tuist generate SDKConfigBenchmarkApp
+// Without it, a direct run reports "BENCH_API_KEY missing" by design (keys never live in
+// source or in committed scheme files).
+let runEnvironment: [String: EnvironmentVariable] = {
+    var environment: [String: EnvironmentVariable] = [:]
+    if let apiKey = Environment.benchApiKey {
+        environment["BENCH_API_KEY"] = .environmentVariable(value: apiKey, isEnabled: true)
+        environment["BENCH_APP_USER_ID"] = .environmentVariable(value: "bench-xcode-run", isEnabled: true)
+    }
+    return environment
+}()
+
+let project = Project(
+    name: "SDKConfigBenchmarkApp",
+    organizationName: .revenueCatOrgName,
+    packages: .projectPackages,
+    settings: .appProject,
+    targets: [
+        .target(
+            name: "SDKConfigBenchmarkApp",
+            destinations: [.iPhone],
+            product: .app,
+            bundleId: "com.revenuecat.SDKConfigBenchmarkApp",
+            deploymentTargets: .iOS("16.0"),
+            infoPlist: "../../Tests/TestingApps/SDKConfigBenchmarkApp/App/Info.plist",
+            sources: [
+                "../../Tests/TestingApps/SDKConfigBenchmarkApp/App/**/*.swift"
+            ],
+            dependencies: [
+                .revenueCat,
+                .revenueCatUI
+            ],
+            settings: .appTarget(including: ([:] as SettingsDictionary).appendingTuistSwiftConditions())
+        ),
+        .target(
+            name: "SDKConfigBenchmarkAppUITests",
+            destinations: [.iPhone],
+            product: .uiTests,
+            bundleId: "com.revenuecat.SDKConfigBenchmarkAppUITests",
+            deploymentTargets: .iOS("16.0"),
+            infoPlist: .default,
+            sources: [
+                "../../Tests/TestingApps/SDKConfigBenchmarkApp/UITests/**/*.swift",
+                // Shared with the app target: the runner decodes the same LaunchSample
+                // the app encodes.
+                "../../Tests/TestingApps/SDKConfigBenchmarkApp/App/LaunchMeasurement.swift"
+            ],
+            dependencies: [
+                .target(name: "SDKConfigBenchmarkApp")
+            ],
+            settings: .appTarget
+        )
+    ],
+    schemes: [
+        .scheme(
+            name: "SDKConfigBenchmarkApp",
+            shared: true,
+            buildAction: .buildAction(targets: ["SDKConfigBenchmarkApp"]),
+            // Release: the rows claim to measure the shipping SDK, so Debug-built
+            // (unoptimized, assertion-enabled) frameworks would misrepresent it.
+            testAction: .targets(
+                ["SDKConfigBenchmarkAppUITests"],
+                configuration: "Release"
+            ),
+            runAction: .runAction(
+                configuration: "Debug",
+                executable: "SDKConfigBenchmarkApp",
+                arguments: .arguments(environmentVariables: runEnvironment)
+            )
+        )
+    ]
+)

Sources/Caching/DeviceCache.swift

@@ -856,6 +856,9 @@ private extension DeviceCache {
 
     // swiftlint:disable avoid_using_directory_apis_directly
     private func oldDocumentsDirectoryURL() -> URL? {
+        #if SDK_CONFIG_BENCHMARK
+        guard !DirectoryHelper.skipsLegacyDocumentsMigrations else { return nil }
+        #endif
         let documentsDirectoryURL: URL?
         if #available(iOS 16.0, macOS 13.0, tvOS 16.0, watchOS 9.0, *) {
             documentsDirectoryURL = URL.documentsDirectory

Sources/Caching/DirectoryHelper.swift

@@ -37,7 +37,35 @@ enum DirectoryHelper {
         return Self.baseUrl(for: directoryType, inAppSpecificDirectory: false)
     }
 
+    #if SDK_CONFIG_BENCHMARK
+    /// Benchmark-only: when set, every SDK disk cache resolves under this root. The standard
+    /// container directories ignore $HOME, so without this override concurrent benchmark
+    /// processes would share (and corrupt) one another's caches in the real user Library.
+    /// Set once at process startup, before any disk access.
+    static var benchmarkBaseDirectoryOverride: URL?
+
+    /// While the override is active, legacy Documents-directory migrations must not run:
+    /// they read, move, and delete files under the real user Documents folder, outside the
+    /// benchmark's sandbox.
+    static var skipsLegacyDocumentsMigrations: Bool {
+        return self.benchmarkBaseDirectoryOverride != nil
+    }
+    #endif
+
     static func baseUrl(for type: DirectoryType, inAppSpecificDirectory: Bool = true) -> URL? {
+        #if SDK_CONFIG_BENCHMARK
+        if let overrideRoot = Self.benchmarkBaseDirectoryOverride {
+            switch type {
+            case .cache:
+                return overrideRoot.appendingPathComponent("caches")
+            #if !os(tvOS)
+            case .applicationSupport:
+                return overrideRoot.appendingPathComponent("application-support")
+            #endif
+            }
+        }
+        #endif
+
         guard let baseDirectory = type.url else {
             return nil
         }

Sources/Networking/HTTPClient/ETagManager.swift

@@ -205,6 +205,9 @@ private extension ETagManager {
     }
 
     private func oldETagDirectoryURL() -> URL? {
+        #if SDK_CONFIG_BENCHMARK
+        guard !DirectoryHelper.skipsLegacyDocumentsMigrations else { return nil }
+        #endif
         // swiftlint:disable:next avoid_using_directory_apis_directly
         guard let documentsURL = Self.fileManager.urls(
             for: .documentDirectory,

Sources/Networking/HTTPClient/HTTPClient.swift

@@ -58,6 +58,9 @@ class HTTPClient {
         config.timeoutIntervalForRequest = requestTimeout
         config.timeoutIntervalForResource = requestTimeout
         config.urlCache = nil // We implement our own caching with `ETagManager`.
+        #if SDK_CONFIG_BENCHMARK
+        config.protocolClasses = [SimulatedTransportURLProtocol.self]
+        #endif
         self.session = URLSession(configuration: config,
                                   delegate: RedirectLoggerSessionDelegate(),
                                   delegateQueue: nil)