Fix logger to only initialize it once

Package.swift

@@ -138,6 +138,7 @@ awsCIoPlatformExcludes.append("source/s2n")
 /// aws-c-checksums
 //////////////////////////////////////////////////////////////////////
 var awsCChecksumsExcludes = [
+    "bin",
     "CMakeLists.txt",
     "LICENSE",
     "builder.json",

Source/AwsCommonRuntimeKit/crt/CommonRuntimeError.swift

@@ -13,13 +13,20 @@ public struct CRTError: Equatable {
     public let message: String
     public let name: String
 
-    public init<T: BinaryInteger>(code: T) {
+    public init<T: BinaryInteger>(code: T, context: String? = nil) {
         if code > INT32_MAX || code <= 0 {
             self.code = Int32(AWS_ERROR_UNKNOWN.rawValue)
         } else {
             self.code = Int32(code)
         }
-        self.message = String(cString: aws_error_str(self.code))
+        var message = String(cString: aws_error_str(self.code))
+        if let context {
+            if message.last != "." {
+                message += "."
+            }
+            message += " " + context
+        }
+        self.message = message 
         self.name = String(cString: aws_error_name(self.code))
     }
 

Source/AwsCommonRuntimeKit/crt/Logger.swift

@@ -2,38 +2,56 @@
 //  SPDX-License-Identifier: Apache-2.0.
 
 import AwsCCommon
-var logger: aws_logger?
+import Foundation
+
+public enum LogTarget {
+    case standardOutput
+    case standardError
+    case filePath(String) 
+}
 
 public struct Logger {
-    public static func initialize(pipe: UnsafeMutablePointer<FILE>?, level: LogLevel) {
-        // Clean up the logger if it was previously initialized
-        if var logger = logger {
-            aws_logger_clean_up(&logger)
-            aws_logger_set(nil)
+    private static var logger: aws_logger?
+    private static let lock = NSLock()
+
+    /// Initializes the CRT logger based on the specified log target and log level. The CRT logger must be only initialized once in your application. Initializing the logger multiple times is not supported.
+    /// - Parameters:
+    ///   - target: The logging target, which can be standard output, standard error, or a custom file path.
+    ///   - level: The logging level, represented by the `LogLevel` enum.
+    /// - Throws: CommonRunTimeError.crtException
+    public static func initialize(target: LogTarget, level: LogLevel) throws {
+        lock.lock()
+        defer { lock.unlock() }
+
+        // Check if the logger is already initialized
+        guard logger == nil else {
+            throw CommonRunTimeError.crtError(CRTError(
+                code: AWS_ERROR_UNSUPPORTED_OPERATION.rawValue, 
+                context: "Initializing the CRT Logger multiple times is not supported."))
         }
+
+        // Initialize the logger
         logger = aws_logger()
         var options = aws_logger_standard_options()
         options.level = level.rawValue
-        options.file = pipe
-        aws_logger_init_standard(&logger!, allocator.rawValue, &options)
-        aws_logger_set(&logger!)
-    }
 
-    public static func initilize(filePath: String, level: LogLevel) {
-        // Clean up the logger if it was previously initialized
-        if var logger = logger {
-            aws_logger_clean_up(&logger)
-            aws_logger_set(nil)
-        }
-        logger = aws_logger()
-
-        filePath.withCString { cFilePath in
-            var options = aws_logger_standard_options()
-            options.level = level.rawValue
-            options.filename = cFilePath
+        // Set options based on the logging target
+        switch target {
+        case .standardOutput:
+            options.file = stdout
             aws_logger_init_standard(&logger!, allocator.rawValue, &options)
-            aws_logger_set(&logger!)
+        case .standardError:
+            options.file = stderr
+            aws_logger_init_standard(&logger!, allocator.rawValue, &options)
+        case .filePath(let filePath):
+            filePath.withCString { cFilePath in
+                options.filename = cFilePath
+                aws_logger_init_standard(&logger!, allocator.rawValue, &options)
+            }
         }
+
+        // Initialize and set the logger
+        aws_logger_set(&logger!)
     }
 }
 

Source/Elasticurl/Elasticurl.swift

@@ -220,10 +220,10 @@ struct Elasticurl {
         createOutputFile()
         if let traceFile = context.traceFile {
             print("enable logging with trace file")
-            Logger.initilize(filePath: traceFile, level: context.logLevel)
+            try? Logger.initialize(target: .filePath(traceFile), level: context.logLevel)
         } else {
             print("enable logging with stdout")
-            Logger.initialize(pipe: stdout, level: context.logLevel)
+            try? Logger.initialize(target: .standardOutput, level: context.logLevel)
         }
 
         await run()

Test/AwsCommonRuntimeKitTests/XCBaseTestCase.swift

@@ -7,13 +7,13 @@ import AwsCCommon
 
 class XCBaseTestCase: XCTestCase {
     internal let tracingAllocator = TracingAllocator(tracingStacksOf: allocator)
-
+    
     override func setUp() {
         super.setUp()
         // XCode currently lacks a way to enable logs exclusively for failed tests only.
         // To prevent log spamming, we use `error` log level to only print error message.
         // We should update this once a more efficient log processing method becomes available.
-        Logger.initialize(pipe: stdout, level: .error)
+        try? Logger.initialize(target: .standardOutput, level: .error)
 
         // Override the allocator with tracing allocator
         allocator = tracingAllocator.rawValue