लॉग लिखें और देखें


लॉगिंग, कोड को डीबग करने और उसकी निगरानी करने का एक अहम टूल है. Cloud Functions की मदद से, Node.js या Python के लिए लॉगर एसडीके टूल का इस्तेमाल किया जा सकता है. इसके अलावा, वेब के लिए डेवलपमेंट करने के लिए console ऑब्जेक्ट स्टैंडर्ड का इस्तेमाल किया जा सकता है.

Cloud Logging के लिए शुल्क लिया जाता है. अगर आपने बिना किसी शुल्क के मिलने वाले कोटे से ज़्यादा इस्तेमाल किया है, तो आपसे शुल्क लिया जा सकता है. ज़्यादा जानकारी के लिए, Cloud Logging का शुल्क देखें.

लॉग लिखना

Cloud Functions logger SDK का इस्तेमाल करना

Cloud Functions logger SDK, Cloud Logging को फ़ंक्शन से स्टेटस रिपोर्ट करने के लिए एक स्टैंडर्ड इंटरफ़ेस उपलब्ध कराता है. इस एसडीके का इस्तेमाल करके, स्ट्रक्चर्ड डेटा के साथ इवेंट लॉग किए जा सकते हैं. इससे, विश्लेषण और निगरानी करना आसान हो जाता है.

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

  • logger.log() कमांड का लॉग लेवल INFO होता है.

  • logger.info() कमांड का लॉग लेवल INFO होता है.

  • logger.warn() कमांड में WARNING लॉग लेवल होता है.

  • logger.error() कमांड में ERROR लॉग लेवल होता है.

  • logger.debug() कमांड में DEBUG लॉग लेवल होता है.

  • सिस्टम के इंटरनल मैसेज का लॉग लेवल DEBUG होता है.

इस उदाहरण में, एक फ़ंक्शन दिखाया गया है जो बुनियादी लॉग लिखता है:

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

अपने फ़ंक्शन कोड में अलग-अलग तरह के लॉग के लिए, अलग-अलग लॉग लेवल का इस्तेमाल करें. स्ट्रक्चर्ड डेटा को लॉग में आखिरी आर्ग्युमेंट के तौर पर जोड़ा जा सकता है. यहां एक उदाहरण दिया गया है, जिसमें बताया गया है कि कोई फ़ंक्शन हर तरह के लॉग का इस्तेमाल कैसे कर सकता है:

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

logger.write() की मदद से, CRITICAL, ALERT, और EMERGENCY के अतिरिक्त लॉग सीवरिटी लेवल के साथ लॉग एंट्री लिखी जा सकती हैं. 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

console.log का इस्तेमाल करना

किसी फ़ंक्शन से लॉग करने के लिए, अपने प्लैटफ़ॉर्म के लिए लॉगर एसडीके का इस्तेमाल करने का सुझाव दिया जाता है. Node.js के साथ, स्टैंडर्ड JavaScript लॉगिंग कॉल का इस्तेमाल किया जा सकता है. जैसे, console.log और console.error. हालांकि, इसके लिए आपको पहले एक खास मॉड्यूल की ज़रूरत होगी, ताकि स्टैंडर्ड तरीके सही तरीके से काम कर सकें:

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

लॉगर के साथ काम करने वाले मॉड्यूल की ज़रूरत होने पर, अपने कोड में console.log() तरीकों का इस्तेमाल सामान्य तरीके से किया जा सकता है:

exports.helloError = functions.https.onRequest((request, response) => {
  console.log('I am a log entry!');
  response.send('Hello World...');
});
index.js
  • console.log() कमांड का लॉग लेवल INFO होता है.
  • console.info() कमांड का लॉग लेवल INFO होता है.
  • console.warn() कमांड में ERROR लॉग लेवल होता है.
  • console.error() कमांड में ERROR लॉग लेवल होता है.
  • सिस्टम के इंटरनल मैसेज का लॉग लेवल DEBUG होता है.

लॉग देखना

Cloud Functions के लॉग, Google Cloud कंसोल, Cloud Logging यूज़र इंटरफ़ेस (यूआई) या firebase कमांड-लाइन टूल के ज़रिए देखे जा सकते हैं.

Firebase CLI का इस्तेमाल करना

firebase टूल की मदद से लॉग देखने के लिए, functions:log कमांड का इस्तेमाल करें:

firebase functions:log

किसी फ़ंक्शन के लॉग देखने के लिए, फ़ंक्शन का नाम आर्ग्युमेंट के तौर पर दें:

firebase functions:log --only <FUNCTION_NAME>

लॉग देखने के सभी विकल्पों के बारे में जानने के लिए, functions:log के लिए उपलब्ध सहायता देखें:

firebase help functions:log

Google Cloud कंसोल का इस्तेमाल करना

Google Cloud कंसोल में जाकर, फ़ंक्शन के लॉग देखे जा सकते हैं.

Cloud Logging यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल करना

Cloud Logging यूज़र इंटरफ़ेस में जाकर, Cloud Functions के लॉग देखे जा सकते हैं.

लॉग का विश्लेषण करना

Cloud Logging, लॉग का विश्लेषण करने वाले टूल का एक बेहतरीन सुइट उपलब्ध कराता है. इसका इस्तेमाल करके, Cloud Functions को मॉनिटर किया जा सकता है.

चार्ट और सूचनाएं

अपने फ़ंक्शन की निगरानी करने के लिए, लॉग पर आधारित मेट्रिक बनाने के बाद, इन मेट्रिक के आधार पर चार्ट और सूचनाएं बनाई जा सकती हैं. उदाहरण के लिए, समय के साथ लेटेन्सी को विज़ुअलाइज़ करने के लिए, एक चार्ट बनाया जा सकता है. इसके अलावा, अगर कोई गड़बड़ी बार-बार होती है, तो इसकी सूचना पाने के लिए एक सूचना बनाई जा सकती है.

चार्ट और सूचना देने की नीतियों में, लॉग पर आधारित मेट्रिक इस्तेमाल करने के तरीके के बारे में ज़्यादा जानने के लिए, चार्ट और सूचनाएं बनाना लेख पढ़ें.

एक्ज़ीक्यूशन आईडी को समझना और उनका इस्तेमाल करना

Cloud Run फ़ंक्शन (दूसरी जनरेशन) में, डिफ़ॉल्ट रूप से एक ही फ़ंक्शन इंस्टेंस में कई अनुरोधों को एक साथ प्रोसेस करने की सुविधा होती है. इसका मतलब है कि अलग-अलग अनुरोधों के लॉग को इंटरलीव किया जा सकता है. इससे किसी एक अनुरोध के एक्ज़ीक्यूशन के फ़्लो को समझना मुश्किल हो जाता है.

इसके लिए, Firebase CLI के वर्शन 13.33.0 और इसके बाद के वर्शन का इस्तेमाल करके डिप्लॉय किए गए फ़ंक्शन, अपने-आप डिप्लॉय हो जाते हैं. साथ ही, इनमें हर लॉग एंट्री के साथ एक्ज़ीक्यूशन आईडी को जोड़ने का विकल्प होता है. यह लॉग एंट्री, एक्ज़ीक्यूशन को हैंडल करने के दौरान जनरेट होती है.

एक्ज़ीक्यूशन आईडी, एक ही अनुरोध से जुड़े उन सभी लॉग की खास तौर पर पहचान करता है जिन्हें आपके फ़ंक्शन ने हैंडल किया है. इसके लिए, कोड में कोई बदलाव करने की ज़रूरत नहीं होती. एक्ज़ीक्यूशन आईडी, आपके लॉग में अपने-आप जुड़ जाएगा.

अपनी लॉग एंट्री में लॉगिंग एक्ज़ीक्यूशन आईडी को बंद करने के लिए, अपनी dotenv फ़ाइल में एनवायरमेंट वैरिएबल LOG_EXECUTION_ID को false पर सेट करें.

एक्ज़ीक्यूशन आईडी के हिसाब से लॉग ढूंढना और उन्हें एक-दूसरे से जोड़ना

Cloud Logs Explorer में, एक्ज़ीक्यूशन आईडी के हिसाब से लॉग की जांच की जा सकती है और उन्हें एक-दूसरे से जोड़ा जा सकता है.

  1. अपने फ़ंक्शन की लॉग एंट्री को बड़ा करें. एक्ज़ीक्यूशन आईडी, स्ट्रक्चर्ड लॉग डेटा में मौजूद होता है. यह labels.execution_id के तौर पर लेबल में नेस्ट किया जाता है.

  2. execution_id की वैल्यू पर क्लिक करें. इसके बाद, ड्रॉप-डाउन मेन्यू से "मिलती-जुलती एंट्री दिखाएं" चुनें. ऐसा करने पर, आपको उसी फ़ंक्शन के एक्ज़ीक्यूशन से जुड़े अन्य सभी लॉग दिखेंगे.

एक्ज़ीक्यूशन आईडी का इस्तेमाल करके, एक ही अनुरोध से जुड़े सभी लॉग मैसेज को एक साथ ग्रुप किया जा सकता है. भले ही, आपका फ़ंक्शन एक साथ कई अनुरोधों को हैंडल कर रहा हो.

कस्टम खास जानकारी वाले फ़ील्ड की मदद से, लॉग की विज़िबिलिटी बढ़ाना

लॉग एक्सप्लोरर में एक्ज़ीक्यूशन आईडी को ज़्यादा आसानी से देखने के लिए, इसे कस्टम खास जानकारी वाले फ़ील्ड के तौर पर जोड़ा जा सकता है. यह हर लॉग एंट्री लाइन की शुरुआत में, एक्ज़ीक्यूशन आईडी को चिप के तौर पर दिखाता है. यह ठीक उसी तरह काम करता है जिस तरह पहली जनरेशन के फ़ंक्शन, सभी लॉग एंट्री के लिए एक्ज़ीक्यूशन आईडी दिखाते थे.

खास जानकारी वाले फ़ील्ड में एक्ज़ीक्यूशन आईडी जोड़ने के लिए:

  1. labels.execution_id में जाकर, स्ट्रक्चर्ड लॉग एंट्री में मौजूद एक्ज़ीक्यूशन आईडी की वैल्यू पर क्लिक करें.

  2. ड्रॉप-डाउन मेन्यू से, "खास जानकारी वाली लाइन में फ़ील्ड जोड़ें" को चुनें.

अब हर लॉग एंट्री में, खास जानकारी वाले फ़ील्ड में executionId प्रमुखता से दिखता है. इससे किसी खास एक्ज़ीक्यूशन आईडी से जुड़े लॉग की पहचान करना और उन्हें ग्रुप करना आसान हो जाता है.