Pisz i przeglądaj dzienniki


Rejestrowanie jest ważnym narzędziem do debugowania i monitorowania kodu. Cloud Functions umożliwia korzystanie z pakietu SDK rejestratora dla Node.js lub Pythona albo standardu obiektu console do programowania dla Internetu.

Cloud Logging jest usługą odpłatną; w przypadku przekroczenia limitu bezpłatnych kosztów może zostać naliczona opłata. Aby uzyskać więcej informacji, zobacz Cennik usługi Cloud Logging .

Pisanie logów

Korzystanie z pakietu SDK rejestratora Cloud Functions

Pakiet SDK rejestratora Cloud Functions zapewnia standardowy interfejs do raportowania stanu funkcji do Cloud Logging. Za pomocą tego pakietu SDK możesz rejestrować zdarzenia za pomocą uporządkowanych danych , co ułatwia analizę i monitorowanie.

Import z podpakietu logger :

Node.js

// All available logging functions
const {
  log,
  info,
  debug,
  warn,
  error,
  write,
} = require("firebase-functions/logger");
index.js

Pyton

from firebase_functions import logger
main.py

  • Polecenia logger.log() mają poziom dziennika INFO .

  • Polecenia logger.info() mają poziom dziennika INFO .

  • Polecenia logger.warn() mają poziom dziennika WARNING .

  • Polecenia logger.error() mają poziom dziennika ERROR .

  • Polecenia logger.debug() mają poziom dziennika DEBUG .

  • Wewnętrzne komunikaty systemowe posiadają poziom dziennika DEBUG .

Poniższy przykład ilustruje funkcję zapisu podstawowego dziennika:

Node.js

exports.helloWorld = onRequest((request, response) => {
  // sends a log to Cloud Logging
  log("Hello logs!");

  response.send("Hello from Firebase!");
});
index.js

Pyton

@https_fn.on_request()
def hello_world(req: https_fn.Request) -> https_fn.Response:
    # sends a log to Cloud Logging
    logger.log("Hello logs!")

    return https_fn.Response("Hello from Firebase!")
main.py

Użyj różnych poziomów rejestrowania dla różnych typów dzienników w kodzie funkcji. Dane strukturalne można dołączyć do dziennika jako ostatni argument. Oto przykład tego, jak funkcja może używać każdego typu dziennika:

Node.js

exports.getInspirationalQuote = onRequest(async (request, response) => {
  const db = getFirestore();
  const today = new Date();
  const quoteOfTheMonthRef = db
      .collection("quotes")
      .doc(`${today.getFullYear()}`)
      .collection("months")
      .doc(`${today.getMonth()}`);

  const DEFAULT_QUOTE =
      "You miss 100% of the shots you don't take. -Wayne Gretzky";
  let quote;
  try {
    const quoteOfTheMonthDocSnap = await quoteOfTheMonthRef.get();

    // Attach relevant debugging information with debug()
    debug("Monthly quote fetch result", {
      docRef: quoteOfTheMonthRef.path,
      exists: quoteOfTheMonthDocSnap.exists,
      createTime: quoteOfTheMonthDocSnap.createTime,
    });

    if (quoteOfTheMonthDocSnap.exists) {
      quote = quoteOfTheMonthDocSnap.data().text;
    } else {
      // Use warn() for lower-severity issues than error()
      warn("Quote not found for month, sending default instead", {
        docRef: quoteOfTheMonthRef.path,
        dateRequested: today.toLocaleDateString("en-US"),
      });

      quote = DEFAULT_QUOTE;
    }
  } catch (err) {
    // Attach an error object as the second argument
    error("Unable to read quote from Firestore, sending default instead",
        err);

    quote = DEFAULT_QUOTE;
  }

  // Attach relevant structured data to any log
  info("Sending a quote!", {quote: quote});
  response.json({inspirationalQuote: quote});
});
index.js

Pyton

@https_fn.on_request()
def get_inspirational_quote(req: https_fn.Request) -> https_fn.Response:
    firestore_client = firestore.client()
    today = datetime.date.today()
    quote_of_the_month_ref = (firestore_client.collection("quotes").doc(str(
        today.year)).collection("months").doc(str(today.month)))

    default_quote = "Python has been an important part of Google since the beginning, and remains so as the system grows and evolves."

    quote = None
    try:
        quote_of_the_month = quote_of_the_month_ref.get()

        # Attach relevant debugging information with debug()
        logger.debug(
            "Monthly quote fetch result",
            docRef=quote_of_the_month.path,
            exists=quote_of_the_month.exists,
            createTime=quote_of_the_month.createTime,
        )

        if quote_of_the_month.exists:
            quote = quote_of_the_month.to_dict()["text"]
        else:
            # Use warn() for lower-severity issues than error()
            logger.warn(
                "Quote not found for month, sending default instead",
                doc_reference=quote_of_the_month.path,
                date_requested=today.strftime("%Y-%m-%d"),
            )
            quote = default_quote
    except:
        e = sys.exc_info()[0]
        # Attach an error object as the second argument
        logger.error("Unable to read quote from Firestore, sending default instead", error=e)
        quote = default_quote

    # Attach relevant structured data to any log
    logger.info("Sending a quote!", quote=quote)
    return https_fn.Response("Hello from Firebase!")
main.py

Za pomocą logger.write() można zapisywać wpisy dziennika z dodatkowymi poziomami ważności dziennika: CRITICAL , ALERT i EMERGENCY . Zobacz LogSeverity .

Node.js

exports.appHasARegression = onRegressionAlertPublished((event) => {
  write({
    // write() lets you set additional severity levels
    // beyond the built-in logger functions
    severity: "EMERGENCY",
    message: "Regression in production app",
    issue: event.data.payload.issue,
    lastOccurred: event.data.payload.resolveTime,
  });
});
index.js

Pyton

@crashlytics_fn.on_regression_alert_published()
def app_has_regression(alert: crashlytics_fn.CrashlyticsRegressionAlertEvent) -> None:
    logger.write(
        severity="EMERGENCY",
        message="Regression in production app",
        issue=alert.data.payload.issue,
        last_occurred=alert.data.payload.resolve_time,
    )
    print(alert)
main.py

Korzystanie z pliku console.log

Zalecanym rozwiązaniem do rejestrowania z funkcji jest użycie zestawu SDK rejestratora dla Twojej platformy. W Node.js możesz zamiast tego używać standardowych wywołań rejestrowania JavaScript, takich jak console.log i console.error , ale najpierw musisz potrzebować specjalnego modułu, aby załatać standardowe metody, aby działały poprawnie:

require("firebase-functions/logger/compat");

Gdy będziesz już potrzebował modułu zgodności z rejestratorem, możesz normalnie używać metod console.log() w swoim kodzie:

exports.helloError = functions.https.onRequest((request, response) => {
  console.log('I am a log entry!');
  response.send('Hello World...');
});
index.js
  • Polecenia console.log() mają poziom dziennika INFO .
  • Polecenia console.info() mają poziom dziennika INFO .
  • Polecenia console.warn() mają poziom dziennika ERROR .
  • Polecenia console.error() mają poziom dziennika ERROR .
  • Wewnętrzne komunikaty systemowe posiadają poziom dziennika DEBUG .

Przeglądanie logów

Dzienniki funkcji Cloud Functions można przeglądać w konsoli Google Cloud , interfejsie użytkownika Cloud Logging lub za pomocą narzędzia wiersza poleceń firebase .

Korzystanie z interfejsu wiersza polecenia Firebase

Aby wyświetlić logi za pomocą narzędzia firebase , użyj functions:log :

firebase functions:log

Aby wyświetlić logi dla określonej funkcji, podaj nazwę funkcji jako argument:

firebase functions:log --only <FUNCTION_NAME>

Pełny zakres opcji przeglądania logów znajdziesz w pomocy dla functions:log :

firebase help functions:log

Korzystanie z konsoli Google Cloud

Dzienniki funkcji możesz przeglądać w konsoli Google Cloud .

Korzystanie z interfejsu użytkownika Cloud Logging

Dzienniki Cloud Functions możesz przeglądać w interfejsie Cloud Logging.

Analizowanie logów

Cloud Logging oferuje potężny zestaw narzędzi do analizy logów, których możesz używać do monitorowania Funkcji Cloud.

Wykresy i alerty

Po utworzeniu metryk opartych na dziennikach w celu monitorowania funkcji można tworzyć wykresy i alerty na podstawie tych metryk. Można na przykład utworzyć wykres wizualizujący opóźnienia w czasie lub utworzyć alert informujący o zbyt częstym występowaniu określonego błędu.

Szczegółowe informacje na temat używania metryk opartych na dziennikach na wykresach i zasadach tworzenia alertów można znaleźć w sekcji Tworzenie wykresów i alertów.