Cómo escribir y visualizar registros


Los registros son una herramienta importante para depurar y supervisar el código. Cloud Functions te brinda la opción de usar el SDK de registrador para Node.js o Python, o el estándar de objetos console para desarrollar para la Web.

Cloud Logging es un servicio que se cobra, por lo que se aplicarán cargos si superas la cuota sin costo. Para obtener más información, consulta Precios de Cloud Logging.

Escribe registros

Usa el SDK del logger de Cloud Functions

El SDK de registrador de Cloud Functions proporciona una interfaz estándar para informar el estado de las funciones a Cloud Logging. Puedes usar este SDK para registrar eventos con datos estructurados y, así, simplificar la supervisión y el análisis.

Importa desde el subpaquete logger:

Node.js

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

Python

from firebase_functions import logger
main.py

  • Los comandos logger.log() tienen el nivel de registro INFO.

  • Los comandos logger.info() tienen el nivel de registro INFO.

  • Los comandos logger.warn() tienen el nivel de registro ADVERTENCIA.

  • Los comandos logger.error() tienen el nivel de registro ERROR.

  • Los comandos logger.debug() tienen el nivel de registro DEBUG.

  • Los mensajes internos del sistema tienen el nivel de registro DEBUG.

En este ejemplo, se muestra una función que escribe un registro básico:

Node.js

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

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

Python

@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

Usa niveles de registro variados para los diferentes tipos de registro en el código de tu función. Los datos estructurados se pueden adjuntar a un registro como último argumento. Este es un ejemplo de cómo una función puede usar cada tipo de registro:

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

Python

@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

Con logger.write(), puedes escribir entradas de registro con niveles de gravedad de registro adicionales de CRITICAL, ALERT y EMERGENCY. Consulta 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

Python

@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

Usa console.log

La solución recomendada para generar registros desde una función es usar el SDK de registrador para tu plataforma. Con Node.js, puedes usar llamadas de registro estándares de JavaScript, como console.log y console.error, pero primero necesitas un módulo especial para aplicar parches a los métodos estándar a fin de que funcionen correctamente:

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

Cuando hayas establecido el requisito de instalación del módulo de compatibilidad del logger, podrás usar los métodos console.log() como de costumbre en tu código:

exports.helloError = functions.https.onRequest((request, response) => {
  console.log('I am a log entry!');
  response.send('Hello World...');
});
index.js
  • Los comandos console.log() tienen el nivel de registro INFO.
  • Los comandos console.info() tienen el nivel de registro INFO.
  • Los comandos console.warn() tienen el nivel de registro ERROR.
  • Los comandos console.error() tienen el nivel de registro ERROR.
  • Los mensajes internos del sistema tienen el nivel de registro DEBUG.

Visualiza los registros

Los registros de Cloud Functions se pueden ver en la consola de Google Cloud, la IU de Cloud Logging o a través de la herramienta de línea de comandos de firebase.

Usa Firebase CLI

Para visualizar los registros con la herramienta de firebase, usa el comando functions:log:

firebase functions:log

Para visualizar los registros de una función específica, proporciona su nombre como argumento:

firebase functions:log --only <FUNCTION_NAME>

Para conocer todas las opciones de visualización de registros, consulta la ayuda de functions:log:

firebase help functions:log

Usa la consola de Google Cloud

Puedes ver los registros de las funciones en la consola de Google Cloud.

Usa la IU de Cloud Logging

Puedes ver los registros de Cloud Functions en la IU de Cloud Logging.

Analiza registros

Cloud Logging ofrece un conjunto sólido de herramientas de análisis de registros que puedes usar para supervisar Cloud Functions.

Gráficos y alertas

Una vez que crees métricas basadas en registros para supervisar tus funciones, puedes usarlas con el fin de crear gráficos y alertas. Por ejemplo, puedes crear un gráfico para visualizar la latencia a lo largo del tiempo o crear una alerta a fin de saber si un error se produce con mucha frecuencia.

Consulta Crea gráficos y alertas si necesitas información detallada para usar métricas basadas en registros en políticas de alertas y gráficos.