[Vertex AI] Migrate logging to FirebaseLogger

# Conflicts:
#	FirebaseVertexAI/Sources/Safety.swift

Author: andrewheard

FirebaseVertexAI/Sources/GenerateContentResponse.swift

@@ -42,8 +42,11 @@ public struct GenerateContentResponse: Sendable {
   /// The response's content as text, if it exists.
   public var text: String? {
     guard let candidate = candidates.first else {
-      Logging.default
-        .error("[FirebaseVertexAI] Could not get text from a response that had no candidates.")
+      Logging.logEvent(
+        level: .error,
+        message: "Could not get text from a response that had no candidates.",
+        messageCode: .generateContentResponseNoCandidates
+      )
       return nil
     }
     let textValues: [String] = candidate.content.parts.compactMap { part in
@@ -53,8 +56,11 @@ public struct GenerateContentResponse: Sendable {
       return text
     }
     guard textValues.count > 0 else {
-      Logging.default
-        .error("[FirebaseVertexAI] Could not get a text part from the first candidate.")
+      Logging.logEvent(
+        level: .error,
+        message: "Could not get a text part from the first candidate.",
+        messageCode: .generateContentResponseNoText
+      )
       return nil
     }
     return textValues.joined(separator: " ")
@@ -330,8 +336,11 @@ extension FinishReason: Decodable {
   public init(from decoder: Decoder) throws {
     let value = try decoder.singleValueContainer().decode(String.self)
     guard let decodedFinishReason = FinishReason(rawValue: value) else {
-      Logging.default
-        .error("[FirebaseVertexAI] Unrecognized FinishReason with value \"\(value)\".")
+      Logging.logEvent(
+        level: .error,
+        message: "Unrecognized FinishReason with value \"\(value)\".",
+        messageCode: .generateContentResponseUnrecognizedFinishReason
+      )
       self = .unknown
       return
     }
@@ -345,8 +354,11 @@ extension PromptFeedback.BlockReason: Decodable {
   public init(from decoder: Decoder) throws {
     let value = try decoder.singleValueContainer().decode(String.self)
     guard let decodedBlockReason = PromptFeedback.BlockReason(rawValue: value) else {
-      Logging.default
-        .error("[FirebaseVertexAI] Unrecognized BlockReason with value \"\(value)\".")
+      Logging.logEvent(
+        level: .error,
+        message: "Unrecognized BlockReason with value \"\(value)\".",
+        messageCode: .generateContentResponseUnrecognizedBlockReason
+      )
       self = .unknown
       return
     }

FirebaseVertexAI/Sources/GenerativeAIService.swift

@@ -16,6 +16,7 @@ import FirebaseAppCheckInterop
 import FirebaseAuthInterop
 import FirebaseCore
 import Foundation
+import os.log
 
 @available(iOS 15.0, macOS 11.0, macCatalyst 15.0, tvOS 15.0, watchOS 8.0, *)
 struct GenerativeAIService {
@@ -60,9 +61,17 @@ struct GenerativeAIService {
 
     // Verify the status code is 200
     guard response.statusCode == 200 else {
-      Logging.network.error("[FirebaseVertexAI] The server responded with an error: \(response)")
+      Logging.logEvent(
+        level: .error,
+        message: "The server responded with an error: \(response)",
+        messageCode: .loadRequestResponseError
+      )
       if let responseString = String(data: data, encoding: .utf8) {
-        Logging.default.error("[FirebaseVertexAI] Response payload: \(responseString)")
+        Logging.logEvent(
+          level: .error,
+          message: "Response payload: \(responseString)",
+          messageCode: .loadRequestResponseErrorPayload
+        )
       }
 
       throw parseError(responseData: data)
@@ -108,14 +117,21 @@ struct GenerativeAIService {
 
         // Verify the status code is 200
         guard response.statusCode == 200 else {
-          Logging.network
-            .error("[FirebaseVertexAI] The server responded with an error: \(response)")
+          Logging.logEvent(
+            level: .error,
+            message: "The server responded with an error: \(response)",
+            messageCode: .loadRequestStreamResponseError
+          )
           var responseBody = ""
           for try await line in stream.lines {
             responseBody += line + "\n"
           }
 
-          Logging.default.error("[FirebaseVertexAI] Response payload: \(responseBody)")
+          Logging.logEvent(
+            level: .error,
+            message: "Response payload: \(responseBody)",
+            messageCode: .loadRequestStreamResponseErrorPayload
+          )
           continuation.finish(throwing: parseError(responseBody: responseBody))
 
           return
@@ -127,7 +143,11 @@ struct GenerativeAIService {
         let decoder = JSONDecoder()
         decoder.keyDecodingStrategy = .convertFromSnakeCase
         for try await line in stream.lines {
-          Logging.network.debug("[FirebaseVertexAI] Stream response: \(line)")
+          Logging.logEvent(
+            level: .debug,
+            message: "Stream response: \(line)",
+            messageCode: .loadRequestStreamResponseLine
+          )
 
           if line.hasPrefix("data:") {
             // We can assume 5 characters since it's utf-8 encoded, removing `data:`.
@@ -179,8 +199,11 @@ struct GenerativeAIService {
       let tokenResult = await appCheck.getToken(forcingRefresh: false)
       urlRequest.setValue(tokenResult.token, forHTTPHeaderField: "X-Firebase-AppCheck")
       if let error = tokenResult.error {
-        Logging.default
-          .debug("[FirebaseVertexAI] Failed to fetch AppCheck token. Error: \(error)")
+        Logging.logEvent(
+          level: .error,
+          message: "Failed to fetch AppCheck token. Error: \(error)",
+          messageCode: .appCheckTokenFetchFailed
+        )
       }
     }
 
@@ -202,10 +225,11 @@ struct GenerativeAIService {
   private func httpResponse(urlResponse: URLResponse) throws -> HTTPURLResponse {
     // Verify the status code is 200
     guard let response = urlResponse as? HTTPURLResponse else {
-      Logging.default
-        .error(
-          "[FirebaseVertexAI] Response wasn't an HTTP response, internal error \(urlResponse)"
-        )
+      Logging.logEvent(
+        level: .error,
+        message: "Response wasn't an HTTP response, internal error \(urlResponse)",
+        messageCode: .generativeAIServiceNonHTTPResponse
+      )
       throw NSError(
         domain: "com.google.generative-ai",
         code: -1,
@@ -253,14 +277,14 @@ struct GenerativeAIService {
   // These errors do not produce specific GenerateContentError or CountTokensError cases.
   private func logRPCError(_ error: RPCError) {
     if error.isFirebaseMLServiceDisabledError() {
-      Logging.default.error("""
+      Logging.logEvent(level: .error, message: """
       The Vertex AI for Firebase SDK requires the Firebase ML API `firebaseml.googleapis.com` to \
       be enabled for your project. Get started in the Firebase Console \
       (https://console.firebase.google.com/project/\(projectID)/genai/vertex) or verify that the \
       API is enabled in the Google Cloud Console \
       (https://console.developers.google.com/apis/api/firebaseml.googleapis.com/overview?project=\
       \(projectID)).
-      """)
+      """, messageCode: .firebaseMLAPIDisabled)
     }
   }
 
@@ -269,9 +293,17 @@ struct GenerativeAIService {
       return try JSONDecoder().decode(type, from: data)
     } catch {
       if let json = String(data: data, encoding: .utf8) {
-        Logging.network.error("[FirebaseVertexAI] JSON response: \(json)")
+        Logging.logEvent(
+          level: .error,
+          message: "JSON response: \(json)",
+          messageCode: .loadRequestParseResponseFailedJSON
+        )
       }
-      Logging.default.error("[FirebaseVertexAI] Error decoding server JSON: \(error)")
+      Logging.logEvent(
+        level: .error,
+        message: "Error decoding server JSON: \(error)",
+        messageCode: .loadRequestParseResponseFailedJSONError
+      )
       throw error
     }
   }
@@ -297,9 +329,12 @@ struct GenerativeAIService {
     }
 
     private func printCURLCommand(from request: URLRequest) {
+      guard Logging.additionalLoggingEnabled() else {
+        return
+      }
       let command = cURLCommand(from: request)
-      Logging.verbose.debug("""
-      [FirebaseVertexAI] Creating request with the equivalent cURL command:
+      os_log(.debug, log: Logging.logObject, """
+      \(Logging.service) Creating request with the equivalent cURL command:
       ----- cURL command -----
       \(command, privacy: .private)
       ------------------------

FirebaseVertexAI/Sources/GenerativeModel.swift

@@ -86,22 +86,22 @@ public final class GenerativeModel {
     self.requestOptions = requestOptions
 
     if Logging.additionalLoggingEnabled() {
-      if ProcessInfo.processInfo.arguments.contains(Logging.migrationEnableArgumentKey) {
-        Logging.verbose.debug("""
-        [FirebaseVertexAI] Verbose logging enabled with the \
-        \(Logging.migrationEnableArgumentKey, privacy: .public) launch argument; please migrate to \
-        the \(Logging.enableArgumentKey, privacy: .public) argument to ensure future compatibility.
-        """)
-      } else {
-        Logging.verbose.debug("[FirebaseVertexAI] Verbose logging enabled.")
-      }
+      Logging.logEvent(
+        level: .debug,
+        message: "Verbose logging enabled.",
+        messageCode: .verboseLoggingEnabled
+      )
     } else {
-      Logging.default.info("""
+      Logging.logEvent(level: .info, message: """
       [FirebaseVertexAI] To enable additional logging, add \
-      `\(Logging.enableArgumentKey, privacy: .public)` as a launch argument in Xcode.
-      """)
+      `\(Logging.enableArgumentKey)` as a launch argument in Xcode.
+      """, messageCode: .verboseLoggingDisabled)
     }
-    Logging.default.debug("[FirebaseVertexAI] Model \(name, privacy: .public) initialized.")
+    Logging.logEvent(
+      level: .debug,
+      message: "Model \(name) initialized.",
+      messageCode: .generativeModelInitialized
+    )
   }
 
   /// Generates content from String and/or image inputs, given to the model as a prompt, that are

FirebaseVertexAI/Sources/Logging.swift

@@ -13,59 +13,55 @@
 // limitations under the License.
 
 import Foundation
-import OSLog
+import os.log
 
-@available(iOS 15.0, macOS 11.0, macCatalyst 15.0, tvOS 15.0, watchOS 8.0, *)
-struct Logging {
-  /// Subsystem that should be used for all Loggers.
-  static let subsystem = "com.google.firebase.vertex-ai"
-
-  /// Default category used for most loggers, unless specialized.
-  static let defaultCategory = ""
+@_implementationOnly import FirebaseCoreExtension
 
-  /// The argument required to enable additional logging.
-  static let enableArgumentKey = "-FIRDebugEnabled"
+/// Enum of log messages.
+enum LoggerMessageCode: Int {
+  case unknown = 0
+  case verboseLoggingEnabled
+  case verboseLoggingDisabled
+  case firebaseMLAPIDisabled
+  case generativeModelInitialized
+  case generativeAIServiceNonHTTPResponse
+  case loadRequestResponseError
+  case loadRequestResponseErrorPayload
+  case loadRequestStreamResponseError
+  case loadRequestStreamResponseErrorPayload
+  case loadRequestStreamResponseLine
+  case loadRequestParseResponseFailedJSON
+  case loadRequestParseResponseFailedJSONError
+  case generateContentResponseNoCandidates
+  case generateContentResponseNoText
+  case generateContentResponseUnrecognizedFinishReason
+  case generateContentResponseUnrecognizedBlockReason
+  case generateContentResponseUnrecognizedBlockThreshold
+  case generateContentResponseUnrecognizedHarmProbability
+  case generateContentResponseUnrecognizedHarmCategory
+  case appCheckTokenFetchFailed
+}
 
-  /// The argument required to enable additional logging in the Google AI SDK; used for migration.
-  ///
-  /// To facilitate migration between the SDKs, this launch argument is also accepted to enable
-  /// additional logging at this time, though it is expected to be removed in the future.
-  static let migrationEnableArgumentKey = "-GoogleGenerativeAIDebugLogEnabled"
+enum Logging {
+  /// Log identifier.
+  static let service = "[FirebaseVertexAI]"
 
-  // No initializer available.
-  @available(*, unavailable)
-  private init() {}
+  /// Subsystem that should be used for all Loggers.
+  static let subsystem = "com.google.firebase"
 
-  /// The default logger that is visible for all users. Note: we shouldn't be using anything lower
-  /// than `.notice`.
-  static let `default` = Logger(subsystem: subsystem, category: defaultCategory)
+  static let logObject = OSLog(subsystem: subsystem, category: service)
 
-  /// A non default
-  static let network: Logger = {
-    if additionalLoggingEnabled() {
-      return Logger(subsystem: subsystem, category: "NetworkResponse")
-    } else {
-      // Return a valid logger that's using `OSLog.disabled` as the logger, hiding everything.
-      return Logger(.disabled)
-    }
-  }()
+  /// The argument required to enable additional logging.
+  static let enableArgumentKey = "-FIRDebugEnabled"
 
-  ///
-  static let verbose: Logger = {
-    if additionalLoggingEnabled() {
-      return Logger(subsystem: subsystem, category: defaultCategory)
-    } else {
-      // Return a valid logger that's using `OSLog.disabled` as the logger, hiding everything.
-      return Logger(.disabled)
-    }
-  }()
+  static func logEvent(level: FirebaseLoggerLevel, message: String,
+                       messageCode: LoggerMessageCode) {
+    let code = String(format: "I-VTX%06d", messageCode.rawValue)
+    FirebaseLogger.log(level: level, service: Logging.service, code: code, message: message)
+  }
 
   /// Returns `true` if additional logging has been enabled via a launch argument.
   static func additionalLoggingEnabled() -> Bool {
-    let arguments = ProcessInfo.processInfo.arguments
-    if arguments.contains(enableArgumentKey) || arguments.contains(migrationEnableArgumentKey) {
-      return true
-    }
-    return false
+    return ProcessInfo.processInfo.arguments.contains(enableArgumentKey)
   }
 }

FirebaseVertexAI/Sources/Safety.swift

@@ -121,8 +121,11 @@ extension SafetyRating.HarmProbability: Decodable {
   public init(from decoder: Decoder) throws {
     let value = try decoder.singleValueContainer().decode(String.self)
     guard let decodedProbability = SafetyRating.HarmProbability(rawValue: value) else {
-      Logging.default
-        .error("[FirebaseVertexAI] Unrecognized HarmProbability with value \"\(value)\".")
+      Logging.logEvent(
+        level: .error,
+        message: "Unrecognized HarmProbability with value \"\(value)\".",
+        messageCode: .generateContentResponseUnrecognizedHarmProbability
+      )
       self = .unknown
       return
     }