Option to Attach full logs to messages (#1)

MahdiBM · web-flow · commit e097e726b71d · 2023-09-02T14:28:12.000+03:30
diff --git a/Sources/DiscordLogger/DiscordLogHandler.swift b/Sources/DiscordLogger/DiscordLogHandler.swift
@@ -87,9 +87,9 @@ public struct DiscordLogHandler: LogHandler {
         message: Logger.Message,
         metadata: Logger.Metadata?,
         source: String,
-        file: String,
-        function: String,
-        line: UInt
+        file: String = #fileID,
+        function: String = #function,
+        line: UInt = #line
     ) { 
         let config = logManager.configuration
         
@@ -127,8 +127,22 @@ public struct DiscordLogHandler: LogHandler {
                 })
             )
         )
-        
-        Task { await logManager.include(address: address, embed: embed, level: level) }
+
+        let attachmentDisabled = logManager.configuration.sendFullLogAsAttachment.isDisabled
+        let attachment = attachmentDisabled ? nil : LogInfo(
+            level: level,
+            message: "\(message)",
+            metadata: allMetadata.mapValues(\.description)
+        )
+
+        Task {
+            await logManager.include(
+                address: address,
+                embed: embed,
+                attachment: attachment,
+                level: level
+            )
+        }
     }
 }
 
diff --git a/Sources/DiscordLogger/DiscordLogManager.swift b/Sources/DiscordLogger/DiscordLogManager.swift
@@ -61,9 +61,50 @@ public actor DiscordLogManager {
                 }
             }
         }
-        
+
+        public enum LogAttachmentPolicy: Sendable {
+            case disabled
+            /// Use ``enabled(formatter:)`` for better type-inference by compiler.
+            /// Otherwise you can use this too.
+            case enabled(_formatter: any LogFormatter = .json)
+
+            /// Enable the log attachments.
+            public static var enabled: Self {
+                .enabled(formatter: .json)
+            }
+
+            /// Enable the log attachments.
+            ///
+            /// To enable compiler-helps with `LogFormatter`-extension inferences like `.json`.
+            /// Uses `some LogFormatter` instead of `any LogFormatter` for this reason.
+            ///
+            /// https://github.com/apple/swift/issues/68269
+            public static func enabled(formatter: some LogFormatter = .json) -> Self {
+                .enabled(_formatter: formatter)
+            }
+
+            var formatter: (any LogFormatter)? {
+                switch self {
+                case .disabled:
+                    return nil
+                case .enabled(let formatter):
+                    return formatter
+                }
+            }
+
+            var isDisabled: Bool {
+                switch self {
+                case .disabled:
+                    return true
+                case .enabled:
+                    return false
+                }
+            }
+        }
+
         let frequency: Duration
         let aliveNotice: AliveNotice?
+        let sendFullLogAsAttachment: LogAttachmentPolicy
         let mentions: [Logger.Level: [String]]
         let colors: [Logger.Level: DiscordColor]
         let excludeMetadata: Set<Logger.Level>
@@ -76,6 +117,8 @@ public actor DiscordLogManager {
         ///   - frequency: The frequency of the log-sendings. e.g. if its set to 30s, logs will only be sent once-in-30s. Should not be lower than 10s, because of Discord rate-limits.
         ///   - aliveNotice: Configuration for sending "I am alive" messages every once in a while. Note that alive notices are delayed until it's been `interval`-time past last message.
         ///   e.g. `Logger(label: "Fallback", factory: StreamLogHandler.standardOutput(label:))`
+        ///   - sendFullLogAsAttachment: Whether or not to send the full log as an attachment.
+        ///   The normal logs might need to truncate some stuff when sending as embeds, due to Discord limits.
         ///   - mentions: ID of users/roles to be mentioned for each log-level.
         ///   - colors: Color of the embeds to be used for each log-level.
         ///   - excludeMetadata: Excludes all metadata for these log-levels.
@@ -86,6 +129,7 @@ public actor DiscordLogManager {
         public init(
             frequency: Duration = .seconds(10),
             aliveNotice: AliveNotice? = nil,
+            sendFullLogAsAttachment: LogAttachmentPolicy = .disabled,
             mentions: [Logger.Level: Mention] = [:],
             colors: [Logger.Level: DiscordColor] = [
                 .critical: .purple,
@@ -104,6 +148,7 @@ public actor DiscordLogManager {
         ) {
             self.frequency = frequency
             self.aliveNotice = aliveNotice
+            self.sendFullLogAsAttachment = sendFullLogAsAttachment
             self.mentions = mentions.mapValues { $0.toMentionStrings() }
             self.colors = colors
             self.excludeMetadata = excludeMetadata
@@ -116,6 +161,7 @@ public actor DiscordLogManager {
     
     struct Log: CustomStringConvertible {
         let embed: Embed
+        let attachment: LogInfo?
         let level: Logger.Level?
         let isFirstAliveNotice: Bool
         
@@ -163,13 +209,25 @@ public actor DiscordLogManager {
         self.fallbackLogger = new ?? Logger(label: "DBM.LogManager")
     }
     
-    func include(address: WebhookAddress, embed: Embed, level: Logger.Level) {
-        self.include(address: address, embed: embed, level: level, isFirstAliveNotice: false)
+    func include(
+        address: WebhookAddress,
+        embed: Embed,
+        attachment: LogInfo?,
+        level: Logger.Level
+    ) {
+        self.include(
+            address: address,
+            embed: embed,
+            attachment: attachment,
+            level: level,
+            isFirstAliveNotice: false
+        )
     }
     
     private func include(
         address: WebhookAddress,
         embed: Embed,
+        attachment: LogInfo?,
         level: Logger.Level?,
         isFirstAliveNotice: Bool
     ) {
@@ -187,6 +245,7 @@ public actor DiscordLogManager {
         
         self.logs[address]!.append(.init(
             embed: embed,
+            attachment: attachment,
             level: level,
             isFirstAliveNotice: isFirstAliveNotice
         ))
@@ -232,6 +291,7 @@ public actor DiscordLogManager {
                 timestamp: Date(),
                 color: config.color
             ),
+            attachment: nil,
             level: nil,
             isFirstAliveNotice: isFirstNotice
         )
@@ -295,21 +355,29 @@ public actor DiscordLogManager {
         
         await sendLogsToWebhook(
             content: mentions,
-            embeds: logs.map(\.embed),
+            logs: logs.map({ ($0.embed, $0.attachment) }),
             address: address
         )
         
         self.setUpAliveNotices()
     }
-    
+
     private func sendLogsToWebhook(
         content: String,
-        embeds: [Embed],
+        logs: [(embed: Embed, attachment: LogInfo?)],
         address: WebhookAddress
     ) async {
+        let attachment = makeAttachmentData(attachments: logs.map(\.attachment))
+
         let payload = Payloads.ExecuteWebhook(
             content: content,
-            embeds: embeds
+            embeds: logs.map(\.embed),
+            files: attachment.map { (name, buffer) in
+                [RawFile(data: buffer, filename: name)]
+            },
+            attachments: attachment.map { (name, _) in 
+                [.init(index: 0, filename: name)]
+            }
         )
         do {
             try await self.client.executeWebhookWithResponse(
@@ -323,7 +391,33 @@ public actor DiscordLogManager {
             ])
         }
     }
-    
+
+    private func makeAttachmentData(attachments: [LogInfo?]) -> (name: String, data: ByteBuffer)? {
+        if let formatter = self.configuration.sendFullLogAsAttachment.formatter {
+            let attachments: [LogContainer] = attachments
+                .enumerated()
+                .filter({ $0.element != nil })
+                .map({ LogContainer(number: $0.offset + 1, info: $0.element!) })
+            if attachments.isEmpty {
+                return nil
+            } else {
+                var buffer = formatter.format(logs: attachments)
+                /// Discord has a limit of 25MB of attachments.
+                /// 24MB is already too much for 10 logs, so we just truncate the buffer.
+                let mb24 = 24_000_000
+                if buffer.readableBytes > mb24 {
+                    buffer = buffer.getSlice(at: buffer.readerIndex, length: mb24) ?? ByteBuffer(
+                        string: "<error-could-not-slice-buffer-please-report-on-github-in-DiscordLogger-repo>"
+                    )
+                }
+                let name = formatter.makeFilename(logs: attachments)
+                return (name, buffer)
+            }
+        } else {
+            return nil
+        }
+    }
+
     private func logWarning(
         _ message: Logger.Message,
         metadata: Logger.Metadata? = nil,
diff --git a/Sources/DiscordLogger/LogFormatter.swift b/Sources/DiscordLogger/LogFormatter.swift
@@ -0,0 +1,130 @@
+import struct NIOCore.ByteBuffer
+#if canImport(Darwin)
+import Foundation
+#else
+@preconcurrency import Foundation
+#endif
+
+public protocol LogFormatter: Sendable {
+    func format(logs: [LogContainer]) -> ByteBuffer
+    func makeFilename(logs: [LogContainer]) -> String
+}
+
+extension LogFormatter where Self == JSONLogFormatter {
+    /// Formats the log attachment as a json file.
+    /// The filename won't have a `.json` extension and it contains a time in `gregorian` calendar in `UTC`.
+    /// Use ``LogFormatter.json(withJSONExtension:calendar:timezone:)`` to customize the behavior.
+    public static var json: JSONLogFormatter {
+        .json()
+    }
+
+    /// Formats the log attachment as a json file.
+    /// - Parameters:
+    ///   - withJSONExtension: Whether or not to include the `.json` extension in the filename.
+    ///   Setting this to true might make the file look bad on Desktop in Discord. Defaults to `false`.
+    ///   - timezone: What timezone to use for the date in filenames. Defaults to `UTC`.
+    public static func json(
+        withJSONExtension: Bool = false,
+        calendar: Calendar = .init(identifier: .gregorian),
+        timezone: TimeZone = .init(identifier: "UTC")!
+    ) -> JSONLogFormatter {
+        JSONLogFormatter(
+            withJSONExtension: withJSONExtension,
+            calendar: calendar,
+            timezone: timezone
+        )
+    }
+}
+
+public struct JSONLogFormatter: LogFormatter {
+
+    private struct LogsEncodingContainer: Encodable {
+        let logs: [LogContainer]
+
+        init(_ logs: [LogContainer]) {
+            self.logs = logs
+        }
+
+        private enum CodingKeys: String, CodingKey {
+            case _1 = "1"
+            case _2 = "2"
+            case _3 = "3"
+            case _4 = "4"
+            case _5 = "5"
+            case _6 = "6"
+            case _7 = "7"
+            case _8 = "8"
+            case _9 = "9"
+            case _10 = "10"
+
+            init(int: Int) {
+                switch int {
+                case 1: self = ._1
+                case 2: self = ._2
+                case 3: self = ._3
+                case 4: self = ._4
+                case 5: self = ._5
+                case 6: self = ._6
+                case 7: self = ._7
+                case 8: self = ._8
+                case 9: self = ._9
+                case 10: self = ._10
+                default:
+                    fatalError("Unexpected number in 'LogsEncodingContainer'.")
+                }
+            }
+        }
+
+        func encode(to encoder: any Encoder) throws {
+            var container = encoder.container(keyedBy: CodingKeys.self)
+            for log in logs {
+                let key = CodingKeys(int: log.number)
+                try container.encode(log.info, forKey: key)
+            }
+        }
+    }
+
+    let withJSONExtension: Bool
+    let calendar: Calendar
+    let timezone: TimeZone
+
+    public func format(logs: [LogContainer]) -> ByteBuffer {
+        let encodingContainer = LogsEncodingContainer(logs)
+        let data = try? DiscordGlobalConfiguration.encoder.encode(encodingContainer)
+        return ByteBuffer(data: data ?? Data())
+    }
+
+    public func makeFilename(logs: [LogContainer]) -> String {
+        let date = makeDateString()
+        let prefix = "Logs_\(date)"
+
+        if withJSONExtension {
+            return "\(prefix).json"
+        } else {
+            return prefix
+        }
+    }
+
+    func makeDateString() -> String {
+        let comps = calendar.dateComponents(in: timezone, from: Date())
+
+        func doubleDigit(_ int: Int) -> String {
+            let description = "\(int)"
+            if description.count == 1 {
+                return "0\(description)"
+            } else {
+                return description
+            }
+        }
+        let year = comps.year ?? 0
+        let month = doubleDigit(comps.month  ?? 0)
+        let day = doubleDigit(comps.day ?? 0)
+        let hour = doubleDigit(comps.hour ?? 0)
+        let minute = doubleDigit(comps.minute ?? 0)
+        let second = doubleDigit(comps.second ?? 0)
+
+        let string = "\(year)-\(month)-\(day)_\(hour)-\(minute)-\(second)"
+
+        return string
+    }
+}
diff --git a/Sources/DiscordLogger/LogInfo.swift b/Sources/DiscordLogger/LogInfo.swift
@@ -0,0 +1,23 @@
+import Logging
+
+public struct LogInfo: Sendable, Codable {
+    public let level: Logger.Level
+    public let message: String
+    public let metadata: [String: String]?
+
+    public init(level: Logger.Level, message: String, metadata: [String: String]) {
+        self.level = level
+        self.message = message
+        self.metadata = metadata.isEmpty ? nil : metadata
+    }
+}
+
+public struct LogContainer: Sendable, Codable {
+    public let number: Int
+    public let info: LogInfo
+
+    public init(number: Int, info: LogInfo) {
+        self.number = number
+        self.info = info
+    }
+}
diff --git a/Tests/DiscordLoggerTests/DiscordLogger.swift b/Tests/DiscordLoggerTests/DiscordLogger.swift
