Write and view logs

bookmark_border Stay organized with collections Save and categorize content based on your preferences.

Logging is an important tool for debugging and monitoring code. Cloud Functions gives you the option of using the logger SDK for Node.js or Python, or the console object standard for developing for the web.

Cloud Logging is a chargeable service; you may be billed if you exceed the no-cost quota. For more information, see Cloud Logging pricing.

Writing logs

Using the Cloud Functions logger SDK

The Cloud Functions logger SDK provides a standard interface to report status from functions to Cloud Logging. You can use this SDK to log events with structured data, enabling easier analysis and monitoring.

Import from the logger subpackage:

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

from firebase_functions import logger
main.py

• logger.log() commands have the INFO log level.

• logger.info() commands have the INFO log level.

• logger.warn() commands have the WARNING log level.

• logger.error() commands have the ERROR log level.

• logger.debug() commands have the DEBUG log level.

• Internal system messages have the DEBUG log level.

This example demonstrates a function writing a basic log:

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

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

@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

Use different log levels for different types of log in your function code. Structured data can be attached to a log as the last argument. Here is an example of how a function can use each log type:

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

@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

With logger.write(), you can write log entries with additional log severity levels of CRITICAL, ALERT, and EMERGENCY. See LogSeverity.

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

@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

Using console.log

The recommended solution for logging from a function is to use the logger SDK for your platform. With Node.js, you can instead use standard JavaScript logging calls such as console.log and console.error, but you first need to require a special module to patch the standard methods to work correctly:

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

Once you have required the logger compatibility module, you can use console.log() methods as normal in your code:

exports.helloError = functions.https.onRequest((request, response) => {
  console.log('I am a log entry!');
  response.send('Hello World...');
});
index.js

• console.log() commands have the INFO log level.
• console.info() commands have the INFO log level.
• console.warn() commands have the ERROR log level.
• console.error() commands have the ERROR log level.
• Internal system messages have the DEBUG log level.

Viewing logs

Logs for Cloud Functions are viewable either in the Google Cloud console, Cloud Logging UI, or via the firebase command-line tool.

Using the Firebase CLI

To view logs with the firebase tool, use the functions:log command:

firebase functions:log

To view logs for a specific function, provide the function name as an argument:

firebase functions:log --only <FUNCTION_NAME>

For the full range of log viewing options, view the help for functions:log:

firebase help functions:log

Using the Google Cloud console

You can view logs for functions in the Google Cloud console.

Using the Cloud Logging UI

You can view logs for Cloud Functions in the Cloud Logging UI.

Analyzing logs

Cloud Logging offers a powerful suite of logs analysis tools that you can use to monitor your Cloud Functions.

Charts and alerts

Once you have created logs-based metrics to monitor your functions, you can create charts and alerts based on these metrics. For example, you could create a chart to visualize latency over time, or create an alert to let you know if a certain error occurs too often.

See Creating Charts and Alerts for detailed information on how to use logs-based metrics in charts and alerting policies.

Understand and use execution IDs

By default, Cloud Run functions (2nd gen) supports concurrent execution of multiple requests within a single function instance. This means logs from different requests can be interleaved, making it harder to follow the flow of a single execution.

To help with this, functions deployed using Firebase CLI version 13.33.0 and later automatically deploy with an option to associate an execution ID with each log entry emitted during handling of that execution.

The execution ID uniquely identifies all logs associated with a single request handled by your function. No code changes are required; the execution ID will be automatically added to your logs.

To disable logging execution ID in your log entries, set the environment variable LOG_EXECUTION_ID to false in your dotenv file.

Find and correlate logs by execution ID

You can inspect and correlate logs by execution ID in Cloud Logs Explorer.

1. Expand the log entry from your function. The execution ID is located within the structured log data, nested under labels as labels.execution_id.

2. Click the value of the execution_id and select "Show matching entries" from the drop-down menu to see all other logs associated with that same function execution.

By using the execution ID, you can group together all log messages related to a single request, even if your function is handling multiple requests concurrently.

Enhance log visibility with custom summary fields

To make the execution ID more readily visible in the Logs Explorer, you can add it as a custom summary field. This displays the execution ID as a chip at the beginning of each log entry line, similar to the way 1st Gen functions surfaced execution ID for all log entries.

To add execution ID to summary field:

1. Click the value of the execution ID in the structured log entry under labels.execution_id.

2. Select "Add field to summary line" from the drop-down menu.

Each log entry now displays the executionId prominently in the summary field, making it easier to identify and group logs associated with a specific execution ID.