Xcode 12 fails to compile with swift-log as a dependency about swift-log HOT 16 CLOSED

import FirebaseCrashlytics
import Logging
import UIKit

import Logging

public protocol LogListener {
    var isEnabled: Bool { get set }
    var logLevel: Logger.Level { get set }
    func logMessage(_ logDetails: ATHLogHandler.LogDetails)
}

public class ATHLogHandler: LogHandler {
    public let label: String
    // This only exists as its required by `LogHandler`
    // But we're not going to use it, as its up to the listeners
    public var logLevel: Logging.Logger.Level
    public var listeners: [LogListener]

    public struct LogDetails {
        let level: Logging.Logger.Level
        let message: Logging.Logger.Message
        let metadata: Logging.Logger.Metadata?
        let prettyMetadata: String?
        let file: String
        let function: String
        let line: UInt
        let date: Date
        let formattedMessage: String
    }

    public init(label: String, level: Logging.Logger.Level = .debug, metadata: Logging.Logger.Metadata = [:], listeners: [LogListener]) {
        self.label = label
        self.logLevel = level
        self.metadata = metadata
        self.listeners = listeners
    }

    public func log(level: Logging.Logger.Level, message: Logging.Logger.Message, metadata: Logging.Logger.Metadata?, file: String, function: String, line: UInt) {
        let date = Date()
        let dateString = DateUtils.iso8601Milliseconds.string(from: date)
        let filePath = self.conciseSourcePath(file)
        listeners.forEach { listener in
            guard listener.isEnabled else { return }
            var text = "\(dateString) [\(level)] "
            // only log metadata + file info if we are debug or trace
            if listener.logLevel <= .debug {
                text += "[\(filePath):\(Int(line))] "

                let prettyMetadata = metadata?.isEmpty ?? true
                ? self.prettyMetadata
                : self.prettify(self.metadata.merging(metadata!, uniquingKeysWith: { _, new in new }))

                if let metadata = prettyMetadata {
                     text += "[\(metadata)] "
                }
            }
            if listener.logLevel <= .trace {
                text += "[\(self.label)] "
            }
            text += message.description
            let logDetails = LogDetails(level: level, message: message, metadata: metadata, prettyMetadata: prettyMetadata, file: file, function: function, line: line, date: date, formattedMessage: text)
            listener.logMessage(logDetails)
        }
    }

    /// splits a path on the /'s
    ///
    private func conciseSourcePath(_ path: String) -> String {
        return (path as NSString).lastPathComponent
    }

    public subscript(metadataKey metadataKey: String) -> Logging.Logger.Metadata.Value? {
        get {
            return metadata[metadataKey]
        }
        set {
            metadata[metadataKey] = newValue
        }
    }

    public var metadata = Logger.Metadata() {
        didSet {
            prettyMetadata = prettify(metadata)
        }
    }

    private var prettyMetadata: String?

    private func prettify(_ metadata: Logging.Logger.Metadata) -> String? {
        return !metadata.isEmpty ? metadata.map { "\($0)=\($1)" }.joined(separator: " ") : nil
    }
}

extension LoggingSystem {
    /// Bootstraps a `ATHLogHandler` to the `LoggingSystem`, so that logger will be used in `Logger.init(label:)`.
    ///
    ///     ATHLogHandler.boostrap()
    ///
    /// - Parameters:
    ///   - level: The minimum level of message that the logger will output. This defaults to `.debug`, the lowest level.
    ///   - metadata: Extra metadata to log with the message. This defaults to an empty dictionary.
    public static func bootstrap(level: Logging.Logger.Level = .info, metadata: Logging.Logger.Metadata = [:], listeners: [LogListener]) {
        self.bootstrap { label in
            return ATHLogHandler(label: label, level: level, metadata: metadata, listeners: listeners)
        }
    }
}

struct ATHLogging {
    private static var _log: Logging.Logger?
    static var log: Logging.Logger {
        if let logger = ATHLogging._log {
            return logger
        } else {
            let logger = Logger(label: "com.theathletic.news")
            let buildString: String = "Version: \(String.getAppVersionSemver) Build: \(String.getBuildVersion)"
            let processInfo: ProcessInfo = ProcessInfo.processInfo
            logger.info("\(processInfo.processName) \(buildString) PID: \(processInfo.processIdentifier)")
            ATHLogging._log = logger
            return logger
        }
    }
    #if APPSTORE
    // Production App Store Loggers
    static var listeners: [LogListener] = [
        CrashlyticsLogListener(isEnabled: true, logLevel: .info)
    ]
    #else
    // Development Xcode loggers
    static var listeners: [LogListener] = [
        // Change your desired level here
        AthleticLogListener(isEnabled: true, logLevel: .debug),
        CrashlyticsLogListener(isEnabled: true, logLevel: .trace)
    ]
    #endif
    static func bootstrap() {
        LoggingSystem.bootstrap(level: .trace, listeners: ATHLogging.listeners)
    }

    static func disableProductionLogging() {
        for var listener in ATHLogging.listeners {
            listener.isEnabled = false
        }
    }

    static func enableProductionLogging() {
        for var listener in ATHLogging.listeners {
            listener.isEnabled = true
        }
    }
}

private class AthleticLogListener: LogListener {
    init(isEnabled: Bool, logLevel: Logging.Logger.Level) {
        self.isEnabled = isEnabled
        self.logLevel = logLevel
    }

    var isEnabled: Bool
    var logLevel: Logging.Logger.Level
    func logMessage(_ logDetails: ATHLogHandler.LogDetails) {
        if logLevel <= logDetails.level {
            print(logDetails.formattedMessage)
        }
    }
}

private class CrashlyticsLogListener: LogListener {
    init(isEnabled: Bool, logLevel: Logging.Logger.Level) {
        self.isEnabled = isEnabled
        self.logLevel = logLevel
    }

    var isEnabled: Bool
    var logLevel: Logging.Logger.Level
    func logMessage(_ logDetails: ATHLogHandler.LogDetails) {
        if logLevel <= logDetails.level {
            crashlyticsLog(logDetails.formattedMessage)
        }
    }
}