|
| 1 | +//===----------------------------------------------------------------------===// |
| 2 | +// |
| 3 | +// This source file is part of the Swift.org open source project |
| 4 | +// |
| 5 | +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors |
| 6 | +// Licensed under Apache License v2.0 with Runtime Library Exception |
| 7 | +// |
| 8 | +// See https://swift.org/LICENSE.txt for license information |
| 9 | +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| 10 | +// |
| 11 | +//===----------------------------------------------------------------------===// |
| 12 | + |
| 13 | +import Foundation |
| 14 | +import RegexBuilder |
| 15 | + |
| 16 | +#if !canImport(os) || SOURCEKITLSP_FORCE_NON_DARWIN_LOGGER |
| 17 | +fileprivate struct FailedToCreateFileError: Error, CustomStringConvertible { |
| 18 | + let logFile: URL |
| 19 | + |
| 20 | + var description: String { |
| 21 | + return "Failed to create log file at \(logFile)" |
| 22 | + } |
| 23 | +} |
| 24 | + |
| 25 | +/// The number of log file handles that have been created by this process. |
| 26 | +/// |
| 27 | +/// See comment on `logFileHandle`. |
| 28 | +@LogHandlerActor |
| 29 | +fileprivate var logRotateIndex = 0 |
| 30 | + |
| 31 | +/// The file handle to the current log file. When the file managed by this handle reaches its maximum size, we increment |
| 32 | +/// the `logRotateIndex` by 1 and set the `logFileHandle` to `nil`. This causes a new log file handle with index |
| 33 | +/// `logRotateIndex % logRotateCount` to be created on the next log call. |
| 34 | +@LogHandlerActor |
| 35 | +fileprivate var logFileHandle: FileHandle? |
| 36 | + |
| 37 | +@LogHandlerActor |
| 38 | +func getOrCreateLogFileHandle(logDirectory: URL, logRotateCount: Int) -> FileHandle { |
| 39 | + if let logFileHandle { |
| 40 | + return logFileHandle |
| 41 | + } |
| 42 | + |
| 43 | + // Name must match the regex in `cleanOldLogFiles` and the prefix in `DiagnoseCommand.addNonDarwinLogs`. |
| 44 | + let logFileUrl = logDirectory.appendingPathComponent( |
| 45 | + "sourcekit-lsp-\(ProcessInfo.processInfo.processIdentifier).\(logRotateIndex % logRotateCount).log" |
| 46 | + ) |
| 47 | + |
| 48 | + do { |
| 49 | + try FileManager.default.createDirectory(at: logDirectory, withIntermediateDirectories: true) |
| 50 | + if !FileManager.default.fileExists(atPath: logFileUrl.path) { |
| 51 | + guard FileManager.default.createFile(atPath: logFileUrl.path, contents: nil) else { |
| 52 | + throw FailedToCreateFileError(logFile: logFileUrl) |
| 53 | + } |
| 54 | + } |
| 55 | + let newFileHandle = try FileHandle( |
| 56 | + forWritingTo: logDirectory.appendingPathComponent( |
| 57 | + "sourcekit-lsp-\(ProcessInfo.processInfo.processIdentifier).\(logRotateIndex % logRotateCount).log" |
| 58 | + ) |
| 59 | + ) |
| 60 | + logFileHandle = newFileHandle |
| 61 | + try newFileHandle.truncate(atOffset: 0) |
| 62 | + return newFileHandle |
| 63 | + } catch { |
| 64 | + // If we fail to create a file handle for the log file, log one message about it to stderr and then log to stderr. |
| 65 | + // We will try creating a log file again once this section of the log reaches `maxLogFileSize` but that means that |
| 66 | + // we'll only log this error every `maxLogFileSize` bytes, which is a lot less spammy than logging it on every log |
| 67 | + // call. |
| 68 | + fputs("Failed to open file handle for log file at \(logFileUrl.path): \(error)", stderr) |
| 69 | + logFileHandle = FileHandle.standardError |
| 70 | + return FileHandle.standardError |
| 71 | + } |
| 72 | +} |
| 73 | + |
| 74 | +/// Log the given message to the given log file handle. |
| 75 | +/// |
| 76 | +/// Occasionally check if the log file exceeds the target log size. If this is the case, truncate the beginning of the |
| 77 | +/// log to reduce the log size. |
| 78 | +@LogHandlerActor |
| 79 | +private func logToFile(message: String, logDirectory: URL, logFileMaxBytes: Int, logRotateCount: Int) throws { |
| 80 | + |
| 81 | + guard let data = message.data(using: .utf8) else { |
| 82 | + fputs( |
| 83 | + """ |
| 84 | + Failed to convert log message to UTF-8 data |
| 85 | + \(message) |
| 86 | +
|
| 87 | + """, |
| 88 | + stderr |
| 89 | + ) |
| 90 | + return |
| 91 | + } |
| 92 | + let logFileHandleUnwrapped = getOrCreateLogFileHandle(logDirectory: logDirectory, logRotateCount: logRotateCount) |
| 93 | + try logFileHandleUnwrapped.write(contentsOf: data) |
| 94 | + |
| 95 | + // If this log file has exceeded the maximum size, start writing to a new log file. |
| 96 | + if try logFileHandleUnwrapped.offset() > logFileMaxBytes { |
| 97 | + logRotateIndex += 1 |
| 98 | + // Resetting `logFileHandle` will cause a new logFileHandle to be created on the next log call. |
| 99 | + logFileHandle = nil |
| 100 | + } |
| 101 | +} |
| 102 | + |
| 103 | +/// If the file at the given path is writable, redirect log messages handled by `NonDarwinLogHandler` to the given file. |
| 104 | +/// |
| 105 | +/// Occasionally checks that the log does not exceed `targetLogSize` (in bytes) and truncates the beginning of the log |
| 106 | +/// when it does. |
| 107 | +@LogHandlerActor |
| 108 | +private func setUpGlobalLogFileHandlerImpl(logFileDirectory: URL, logFileMaxBytes: Int, logRotateCount: Int) { |
| 109 | + logHandler = { @LogHandlerActor message in |
| 110 | + do { |
| 111 | + try logToFile( |
| 112 | + message: message, |
| 113 | + logDirectory: logFileDirectory, |
| 114 | + logFileMaxBytes: logFileMaxBytes, |
| 115 | + logRotateCount: logRotateCount |
| 116 | + ) |
| 117 | + } catch { |
| 118 | + fputs( |
| 119 | + """ |
| 120 | + Failed to write message to log file: \(error) |
| 121 | + \(message) |
| 122 | +
|
| 123 | + """, |
| 124 | + stderr |
| 125 | + ) |
| 126 | + } |
| 127 | + } |
| 128 | +} |
| 129 | + |
| 130 | +private func cleanOldLogFilesImpl(logFileDirectory: URL, maxAge: TimeInterval) { |
| 131 | + let enumerator = FileManager.default.enumerator(at: logFileDirectory, includingPropertiesForKeys: nil) |
| 132 | + while let url = enumerator?.nextObject() as? URL { |
| 133 | + let name = url.lastPathComponent |
| 134 | + let regex = Regex { |
| 135 | + "sourcekit-lsp-" |
| 136 | + Capture(ZeroOrMore(.digit)) |
| 137 | + "." |
| 138 | + ZeroOrMore(.digit) |
| 139 | + ".log" |
| 140 | + } |
| 141 | + guard let match = name.matches(of: regex).only, let pid = Int32(match.1) else { |
| 142 | + continue |
| 143 | + } |
| 144 | + if kill(pid, 0) == 0 { |
| 145 | + // Process that owns this log file is still alive. Don't delete it. |
| 146 | + continue |
| 147 | + } |
| 148 | + guard |
| 149 | + let modificationDate = orLog( |
| 150 | + "Getting mtime of old log file", |
| 151 | + { try FileManager.default.attributesOfItem(atPath: url.path)[.modificationDate] } |
| 152 | + ) as? Date, |
| 153 | + Date().timeIntervalSince(modificationDate) > maxAge |
| 154 | + else { |
| 155 | + // File has been modified in the last hour. Don't delete it because it's useful to diagnose issues after |
| 156 | + // sourcekit-lsp has exited. |
| 157 | + continue |
| 158 | + } |
| 159 | + orLog("Deleting old log file") { try FileManager.default.removeItem(at: url) } |
| 160 | + } |
| 161 | +} |
| 162 | +#endif |
| 163 | + |
| 164 | +/// If the file at the given path is writable, redirect log messages handled by `NonDarwinLogHandler` to the given file. |
| 165 | +/// |
| 166 | +/// Occasionally checks that the log does not exceed `targetLogSize` (in bytes) and truncates the beginning of the log |
| 167 | +/// when it does. |
| 168 | +/// |
| 169 | +/// No-op when using OSLog. |
| 170 | +public func setUpGlobalLogFileHandler(logFileDirectory: URL, logFileMaxBytes: Int, logRotateCount: Int) async { |
| 171 | + #if !canImport(os) || SOURCEKITLSP_FORCE_NON_DARWIN_LOGGER |
| 172 | + await setUpGlobalLogFileHandlerImpl( |
| 173 | + logFileDirectory: logFileDirectory, |
| 174 | + logFileMaxBytes: logFileMaxBytes, |
| 175 | + logRotateCount: logRotateCount |
| 176 | + ) |
| 177 | + #endif |
| 178 | +} |
| 179 | + |
| 180 | +/// Deletes all sourcekit-lsp log files in `logFilesDirectory` that are not associated with a running process and that |
| 181 | +/// haven't been modified within the last hour. |
| 182 | +/// |
| 183 | +/// No-op when using OSLog. |
| 184 | +public func cleanOldLogFiles(logFileDirectory: URL, maxAge: TimeInterval) { |
| 185 | + #if !canImport(os) || SOURCEKITLSP_FORCE_NON_DARWIN_LOGGER |
| 186 | + cleanOldLogFilesImpl(logFileDirectory: logFileDirectory, maxAge: maxAge) |
| 187 | + #endif |
| 188 | +} |
0 commit comments