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

डिबगिंग और मॉनिटरिंग कोड के लिए लॉगिंग एक महत्वपूर्ण उपकरण है। क्लाउड फ़ंक्शंस आपको Node.js या Python के लिए लॉगर SDK, या वेब के विकास के लिए console ऑब्जेक्ट मानक का उपयोग करने का विकल्प देता है।

क्लाउड लॉगिंग एक प्रभार्य सेवा है; यदि आप नो-कॉस्ट कोटा से अधिक हो जाते हैं तो आपको बिल भेजा जा सकता है। अधिक जानकारी के लिए, क्लाउड लॉगिंग मूल्य निर्धारण देखें।

लॉग लिखना

क्लाउड फ़ंक्शंस लॉगर SDK का उपयोग करना

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

logger उपपैकेज से आयात करें:

// 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() कमांड में INFO लॉग स्तर होता है।

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

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

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

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

• आंतरिक सिस्टम संदेशों में DEBUG लॉग स्तर होता है।

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

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

अपने फ़ंक्शन कोड में विभिन्न प्रकार के लॉग के लिए विभिन्न लॉग स्तरों का उपयोग करें। संरचित डेटा को अंतिम तर्क के रूप में लॉग से जोड़ा जा सकता है। यहां एक उदाहरण दिया गया है कि कोई फ़ंक्शन प्रत्येक लॉग प्रकार का उपयोग कैसे कर सकता है:

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

logger.write() के साथ, आप CRITICAL , ALERT , और EMERGENCY के अतिरिक्त लॉग गंभीरता स्तरों के साथ लॉग प्रविष्टियाँ लिख सकते हैं। लॉगसेवरिटी देखें।

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

console.log उपयोग करना

किसी फ़ंक्शन से लॉगिंग के लिए अनुशंसित समाधान आपके प्लेटफ़ॉर्म के लिए लॉगर एसडीके का उपयोग करना है। Node.js के साथ, आप इसके बजाय 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() कमांड में त्रुटि लॉग स्तर होता है।
• console.error() कमांड में ERROR लॉग स्तर होता है।
• आंतरिक सिस्टम संदेशों में DEBUG लॉग स्तर होता है।

लॉग देखना

क्लाउड फ़ंक्शंस के लिए लॉग या तो Google क्लाउड कंसोल , क्लाउड लॉगिंग यूआई, या firebase कमांड-लाइन टूल के माध्यम से देखे जा सकते हैं।

फायरबेस सीएलआई का उपयोग करना

firebase टूल के साथ लॉग देखने के लिए, functions:log कमांड का उपयोग करें:

firebase functions:log

किसी विशिष्ट फ़ंक्शन के लिए लॉग देखने के लिए, फ़ंक्शन नाम को तर्क के रूप में प्रदान करें:

firebase functions:log --only <FUNCTION_NAME>

लॉग देखने के विकल्पों की पूरी श्रृंखला के लिए, functions:log :

firebase help functions:log

Google क्लाउड कंसोल का उपयोग करना

आप Google क्लाउड कंसोल में फ़ंक्शंस के लिए लॉग देख सकते हैं।

क्लाउड लॉगिंग यूआई का उपयोग करना

आप क्लाउड लॉगिंग यूआई में क्लाउड फ़ंक्शंस के लिए लॉग देख सकते हैं।

लॉग का विश्लेषण किया जा रहा है

क्लाउड लॉगिंग लॉग विश्लेषण टूल का एक शक्तिशाली सूट प्रदान करता है जिसका उपयोग आप अपने क्लाउड फ़ंक्शंस की निगरानी के लिए कर सकते हैं।

चार्ट और अलर्ट

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

चार्ट और अलर्ट नीतियों में लॉग-आधारित मेट्रिक्स का उपयोग करने के तरीके के बारे में विस्तृत जानकारी के लिए चार्ट और अलर्ट बनाना देखें।