如何使用FirebaseFunctions并记录事件或错误？请求提供FirebaseFunctions Swift库基础使用示例

Hey there! Let's break this down into two clear sections: setting up event/error logging with Firebase Functions (using Node.js, since that's where the official docs are robust) and walking through practical, basic examples for the Firebase Functions Swift library—since I know the official Swift docs are pretty sparse right now.

Firebase Functions has built-in logging tools that integrate directly with the Firebase Console, making it easy to track events and debug errors. Here's how to use them:

Event Logging #

Use functions.logger to record custom events (like user actions, data updates, or successful function executions) with context-rich metadata. This helps you trace what happened and when.

Example HTTP function logging a user action:

const functions = require("firebase-functions");

exports.logUserAction = functions.https.onRequest(async (req, res) => {
  // Log a detailed event with user context
  functions.logger.info("User completed an action", {
    context: {
      userId: req.body.userId,
      actionType: req.body.actionType,
      timestamp: new Date().toISOString(),
      source: "mobile-app"
    }
  });

  res.status(200).send("Action logged successfully");
});

Error Logging #

Catch and log errors with functions.logger.error, including stack traces and request details to simplify debugging. Always wrap critical logic in try/catch blocks to ensure errors are captured.

Example function handling errors during data processing:

exports.processUserUpload = functions.https.onRequest(async (req, res) => {
  try {
    const uploadData = req.body.upload;
    // Simulate an async data processing task
    const processedData = await processUpload(uploadData);
    
    functions.logger.info("Upload processed successfully", {
      userId: req.body.userId,
      uploadSize: uploadData.size
    });
    res.status(200).send(processedData);
  } catch (error) {
    // Log error with full context for debugging
    functions.logger.error("Failed to process upload", {
      errorMessage: error.message,
      errorStack: error.stack,
      userId: req.body.userId,
      failedUploadData: req.body.upload
    });
    res.status(500).send("Error processing your upload");
  }
});

// Dummy processing function
async function processUpload(data) {
  if (!data) throw new Error("No upload data provided");
  return { status: "processed", data: data };
}

All these logs will show up in the Firebase Console > Functions > Logs page, where you can filter by severity, function name, or context metadata.

The Swift SDK for Firebase Functions is less documented, but it's straightforward for calling HTTP and Callable functions from your iOS app. Here's how to get started:

Step 1: Setup & Initialization #

First, make sure you've added the SDK to your project via CocoaPods:

# In your Podfile
pod 'FirebaseFunctions'

Then initialize Firebase and the Functions client in your app (usually in AppDelegate.swift or a dedicated Firebase setup file):

import Firebase
import FirebaseFunctions

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    FirebaseApp.configure()
    
    // Initialize Functions (use your region if not us-central1)
    let functions = Functions.functions()
    // Uncomment if your functions are hosted in a different region:
    // let functions = Functions.functions(region: "europe-west1")
    
    return true
}

Step 2: Call an HTTP-Triggered Function #

If you have an HTTP function like the logUserAction example above, you can call it using URLSession:

// Example: Trigger the logUserAction function from Swift
func logUserActionInFirebase(userId: String, actionType: String) {
    guard let functionURL = URL(string: "https://YOUR_REGION-YOUR_PROJECT_ID.cloudfunctions.net/logUserAction") else {
        print("Invalid function URL")
        return
    }
    
    var request = URLRequest(url: functionURL)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    
    // Prepare request body
    let requestBody: [String: Any] = [
        "userId": userId,
        "actionType": actionType
    ]
    
    do {
        request.httpBody = try JSONSerialization.data(withJSONObject: requestBody)
        let task = URLSession.shared.dataTask(with: request) { data, response, error in
            if let error = error {
                print("Error calling function: \(error.localizedDescription)")
                return
            }
            // Handle success response
            if let data = data, let responseString = String(data: data, encoding: .utf8) {
                print("Function response: \(responseString)")
            }
        }
        task.resume()
    } catch {
        print("Failed to encode request body: \(error.localizedDescription)")
    }
}

Step 3: Call a Callable Function (Recommended) #

Callable functions are better for authenticated requests and automatic JSON serialization. First, define a Callable function in Node.js:

exports.greetAuthenticatedUser = functions.https.onCall((data, context) => {
    // Require authentication
    if (!context.auth) {
        throw new functions.https.HttpsError(
            "unauthenticated",
            "You must be signed in to use this function."
        );
    }
    
    const userName = data.userName || context.auth.token.name || "Guest";
    return { greeting: `Hello, ${userName}! 👋` };
});

Then call it from Swift:

// Example: Call the greetAuthenticatedUser Callable function
func fetchGreeting() {
    let functions = Functions.functions()
    functions.httpsCallable("greetAuthenticatedUser").call(["userName": "Alice"]) { result, error in
        if let error = error as NSError? {
            // Handle Firebase Functions-specific errors
            if error.domain == FunctionsErrorDomain {
                let errorCode = FunctionsErrorCode(rawValue: error.code)
                let errorMessage = error.localizedDescription
                let errorDetails = error.userInfo[FunctionsErrorDetailsKey]
                
                print("Callable function error: \(errorCode?.rawValue ?? 0) - \(errorMessage)")
                if let details = errorDetails {
                    print("Error details: \(details)")
                }
            } else {
                print("General error: \(error.localizedDescription)")
            }
            return
        }
        
        // Parse successful response
        if let response = result?.data as? [String: String], let greeting = response["greeting"] {
            print("Received greeting: \(greeting)")
            // Update UI with the greeting here (remember to dispatch to main thread!)
            DispatchQueue.main.async {
                // self.greetingLabel.text = greeting
            }
        }
    }
}

Note: If your Callable function requires authentication, make sure the user is signed in via Firebase Auth in your Swift app before calling the function.

内容的提问来源于stack exchange，提问作者netsplatter