feat: Add PerformanceTests

PerformanceTests/Package.swift

@@ -0,0 +1,19 @@
+// swift-tools-version: 5.9
+
+import PackageDescription
+
+let package = Package(
+    name: "SDKWorkbench",
+    platforms: [.macOS(.v12), .iOS(.v15)],
+    dependencies: [
+        .package(name: "aws-sdk-swift", path: "../../aws-sdk-swift"),
+    ],
+    targets: [
+        .executableTarget(
+            name: "PerformanceTestRunner",
+            dependencies: [
+                .product(name: "AWSSTS", package: "aws-sdk-swift"),
+            ]
+        ),
+    ]
+)

PerformanceTests/Sources/PerformanceTestRunner/Core/Model/Dimension.swift

@@ -0,0 +1,11 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+struct Dimension: Codable {
+    let name: String
+    let value: String
+}

PerformanceTests/Sources/PerformanceTestRunner/Core/Model/PerformanceTest.swift

@@ -0,0 +1,14 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+protocol PerformanceTest {
+    var name: String { get }
+    var description: String { get }
+    var unit: Unit { get }
+    var dimensions: [Dimension] { get }
+    var test: () async throws -> Double { get }
+}

PerformanceTests/Sources/PerformanceTestRunner/Core/Model/PerformanceTestReport.swift

@@ -0,0 +1,29 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+
+struct PerformanceTestReport: Codable {
+    var productId: String = "AWS SDK for Swift"
+    let sdkVersion: String?
+    let commitId: String
+    let results: [PerformanceTestResult]
+}
+
+extension PerformanceTestReport {
+    func printFormatted() {
+        let jsonEncoder = JSONEncoder()
+        jsonEncoder.outputFormatting = .prettyPrinted
+
+        if let jsonData = try? jsonEncoder.encode(self),
+           let jsonString = String(data: jsonData, encoding: .utf8) {
+            print(jsonString)
+        } else {
+            print("Error encoding JSON")
+        }
+    }
+}

PerformanceTests/Sources/PerformanceTestRunner/Core/Model/PerformanceTestResult.swift

@@ -0,0 +1,15 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+struct PerformanceTestResult: Codable {
+    let name: String
+    let description: String
+    let unit: String
+    let date: Int
+    let measurements: [Double]
+    let dimensions: [Dimension]?
+}

PerformanceTests/Sources/PerformanceTestRunner/Core/Model/Unit.swift

@@ -0,0 +1,21 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+enum Unit: String {
+    case operationsPerSecond = "Operations/Second"
+    case bitsPerSecond = "Bits/Second"
+    case megabitsPerSecond = "Megabits/Second"
+    case gigabitsPerSecond = "Gigabits/Second"
+    case seconds = "Seconds"
+    case milliseconds = "Milliseconds"
+    case microseconds = "Microseconds"
+    case nanoseconds = "Nanoseconds"
+    case bytes = "Bytes"
+    case megabytes = "Megabytes"
+    case gigabytes = "Gigabytes"
+    case percentage = "Percentage"
+}

PerformanceTests/Sources/PerformanceTestRunner/Core/Runners/PerformanceTestRunner.swift

@@ -0,0 +1,34 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+
+struct PerformanceTestRunner {
+
+    var iterations: Int
+
+    /// Executes the given test multiple times
+    func runTest(
+        _ perfTest: PerformanceTest
+    ) async throws -> PerformanceTestResult {
+        var measurements: [Double] = []
+
+        for _ in 0..<iterations {
+            measurements.append(try await perfTest.test())
+        }
+
+        let timestamp = Int(Date().timeIntervalSince1970)
+        return PerformanceTestResult(
+            name: perfTest.name,
+            description: perfTest.description,
+            unit: perfTest.unit.rawValue,
+            date: timestamp,
+            measurements: measurements,
+            dimensions: perfTest.dimensions
+        )
+    }
+}

PerformanceTests/Sources/PerformanceTestRunner/Core/Runners/ProcessRunner.swift

@@ -0,0 +1,43 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+
+struct ProcessRunner {
+    static func runProcess(
+        executable: String = "/usr/bin/env",
+        arguments: [String]
+    ) -> String {
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: executable)
+        process.arguments = arguments
+
+        let outputPipe = Pipe()
+        process.standardOutput = outputPipe
+        process.standardError = Pipe()
+
+        do {
+            try process.run()
+            process.waitUntilExit()
+            let outputData = outputPipe.fileHandleForReading.readDataToEndOfFile()
+            return String(data: outputData, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        } catch {
+            print("ProcessRunner Error: \(error.localizedDescription)")
+            return ""
+        }
+    }
+
+    /// Retrieves the current Git commit ID.
+    static func getGitCommitId() -> String {
+        return ProcessRunner.runProcess(arguments: ["git", "rev-parse", "HEAD"])
+    }
+
+    /// Retrieves the SDK version from a file.
+    static func getSdkVersion() -> String {
+        return ProcessRunner.runProcess(arguments: ["cat", "../../aws-sdk-swift/Package.version"])
+    }
+}

PerformanceTests/Sources/PerformanceTestRunner/Core/Util/OperatingSystem.swift

@@ -0,0 +1,22 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+enum OperatingSystem: String {
+    case macOS = "macOS"
+    case Linux = "Linux"
+    case Unknown = "Unknown"
+
+    static var current: OperatingSystem {
+    #if os(macOS)
+        return .macOS
+    #elseif os(Linux)
+        return .Linux
+    #else
+        return .Unknown
+    #endif
+    }
+}

PerformanceTests/Sources/PerformanceTestRunner/PerformanceMain.swift

@@ -0,0 +1,37 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+import ClientRuntime
+
+// MARK: - Main Entry Point
+@main
+struct PerformanceMain {
+    static func main() async throws {
+        let runner = PerformanceTestRunner(iterations: 5)
+        let commitId = ProcessRunner.getGitCommitId()
+        let sdkVersion = ProcessRunner.getSdkVersion()
+
+        // Add more tests here
+        let performanceTests = [
+            AWSSTSGetCallerIdentity()
+        ]
+
+        var results: [PerformanceTestResult] = []
+        for test in performanceTests {
+            let result = try await runner.runTest(test)
+            results.append(result)
+        }
+
+        let report = PerformanceTestReport(
+            sdkVersion: sdkVersion,
+            commitId: commitId,
+            results: results
+        )
+        report.printFormatted()
+    }
+}

PerformanceTests/Sources/PerformanceTestRunner/Tests/AWSSTSTests.swift

@@ -0,0 +1,30 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import AWSSTS
+import Foundation
+
+struct AWSSTSGetCallerIdentity: PerformanceTest {
+    let name = "sts.getcalleridentity.latency"
+
+    let description = "The total time between initiating a GetCallerIdentity and reading the last byte of the object."
+
+    let unit = Unit.milliseconds
+
+    let dimensions = [
+        Dimension(name: "OS", value: OperatingSystem.current.rawValue),
+    ]
+
+    let test = getCallerIdentity
+
+    static func getCallerIdentity() async throws -> Double {
+        let start = Date()
+        let client = try await STSClient()
+        _ = try await client.getCallerIdentity(input: .init())
+        return Date().timeIntervalSince(start) * 1000  // Convert seconds to milliseconds
+    }
+}