Firebase रीयलटाइम डेटाबेस ऑपरेशन टाइप

Firebase रीयल टाइम डेटाबेस प्रोफ़ाइलर का निर्देश

अपने रीयलटाइम डेटाबेस इंस्टेंस में, स्पीड और बैंडविड्थ के इस्तेमाल की रिपोर्ट जनरेट करने के लिए, नीचे दिए गए कमांड का इस्तेमाल करें:

firebase database:profile

फ़्लैग के विकल्प	ब्यौरा
-h, --help	आउटपुट के इस्तेमाल की जानकारी.
-o, --output FILENAME	आउटपुट को बताई गई फ़ाइल में सेव करें.
-i, --input FILENAME	सर्वर से स्ट्रीम लॉग के बजाय, बताई गई फ़ाइल के आधार पर रिपोर्ट जनरेट करें.
-d, --duration SECONDS	सेकंड की तय संख्या के लिए, डेटाबेस के इस्तेमाल की जानकारी इकट्ठा करें.
--raw	रॉ आंकड़ों को नई लाइन से डीलिमिटेड JSON के तौर पर पाएं.

ऑपरेशन के टाइप

एक ही समय पर कनेक्ट होने की सुविधा

यह कार्रवाई, डेटाबेस से रीयल टाइम कनेक्शन के बारे में बताती है. उदाहरण के लिए, जब कोई नया क्लाइंट SDK टूल के ज़रिए कनेक्ट करता है. RESTफ़ुल कनेक्शन, एक साथ काम करने वाले कनेक्ट ऑपरेशन में नहीं दिखते.

{
    "name": "concurrent-connect",
    "timestamp": 1484776334900
}

एक साथ डिसकनेक्ट होने की सुविधा

एक ही समय पर डिसकनेक्ट होने की वजह से, ऐसा कनेक्शन दिखता है जो डेटाबेस से डिसकनेक्ट हो जाता है. उदाहरण के लिए, जब कोई क्लाइंट डिसकनेक्ट या साइन ऑफ़ करता है.

{
    "name": "concurrent-disconnect",
    "timestamp": 1484776341844
}

realtime-write

रीयल टाइम कनेक्शन से अनुरोध लिखें. उदाहरण के लिए, वेब क्लाइंट के लिए set() और push() ऑपरेशन. मिटाने के अनुरोधों को भी realtime-write ऑपरेशन के तौर पर गिना जाता है और हर 0 बाइट में लिखा गया टेक्स्ट दिखाया जाता है.

{
    "allowed": true, // If security rules allow the operation
    "bytes": 1,
    "millis": 2,
    "name": "realtime-write",
    "path": [
        "foo"
    ],
    "timestamp": 1484776538763
}

realtime-transaction

इस तरह की कार्रवाई में, रीयल टाइम कनेक्शन के ज़रिए किए गए लेन-देन शामिल होते हैं. बार-बार किए गए लेन-देन की वजह, बार-बार की गई कोशिशें और असफल कोशिशें हो सकती हैं.

{
    "allowed": true,
    "bytes": 20,
    "millis": 2,
    "name": "realtime-transaction",
    "path": [
        "foo"
    ],
    "timestamp": 1484776854610
}

रीयलटाइम-अपडेट

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

{
    "allowed": true,
    "bytes": 5,
    "millis": 2,
    "name": "realtime-update",
    "path": [
        "foo"
    ],
    "timestamp": 1484776538769
}

listener-listen

ये कार्रवाइयां किसी क्लाइंट से किसी खास जगह पर डेटा मांगने के शुरुआती अनुरोध को दिखाती हैं. उदाहरण के लिए, वेब क्लाइंट के लिए on() या once() तरीके.

{
    "allowed": true,
    "bytes": 0,
    "millis": 26,
    "name": "listener-listen",
    "path": [
        "foo"
    ],
    "querySet": [],
    "timestamp": 1484776335024,
    "unIndexed": false
}

लिसनर-ब्रॉडकास्ट

इस कार्रवाई में, सर्वर से भेजे जाने वाले ऐसे सभी क्लाइंट को डेटा शामिल किया जाता है जो डेटा लिखने और अपडेट करने की हर कार्रवाई के बाद, किसी दी गई जगह पर मौजूद मैसेज को सुन रहे होते हैं. डेटा में बदलाव करने से ब्रॉडकास्ट ऑपरेशन शुरू हो जाता है. हालांकि, अगर कोई क्लाइंट सुन नहीं रहा है, तो हो सकता है कि आपको कोई अपडेट न दिखे.

{
    "bytes": 56, // Total bytes sent across clients
    "clientsUpdated": 3, // This may be 0 if no clients are listening
    "millis": 17,
    "name": "listener-broadcast",
    "path": [
        "baz",
        "mar"
    ],
    "timestamp": 1484775969928
}

listener-unlisten

ये कार्रवाइयां, उन लिसनिंग क्लाइंट के बारे में बताती हैं जो डिटैच तरीकों (उदाहरण के लिए, वेब के लिए off() या iOS के लिए removeAllObservers) की मदद से, साइन इन करते हैं या सुनना बंद कर देते हैं.

{
    "name": "listener-unlisten",
    "path": [
        "foo"
    ],
    "timestamp": 1484776335044
}

रेस्ट-रीड

REST API के ज़रिए, GET अनुरोध करता है.

{
    "allowed": true,
    "bytes": 348, // This would be 0 if the read data was null
    "millis": 26,
    "name": "rest-read",
    "path": [],
    "querySet": [
        {
            "default": true,
            "endIndexValue": "[MAX_NAME]",
            "equality": false,
            "index": {},
            "limit": null,
            "range": false,
            "simpleLimit": false,
            "startIndexValue": "[MIN_NAME]",
            "viewFrom": null
        }
    ],
    "timestamp": 1484775747416
}

आराम से लिखें

REST API के ज़रिए, PUT और POST अनुरोध किए जाते हैं. DELETE के अनुरोध, 0 बाइट की rest-write कार्रवाइयों को दिखाते हैं.

{
    "allowed": true,
    "bytes": 13,
    "millis": 116,
    "name": "rest-write",
    "path": [],
    "timestamp": 1484775917216
}

बाकी लेन-देन

लेन-देन जैसे व्यवहार के लिए, शर्त वाले अनुरोध इस्तेमाल करें. rest-transaction कार्रवाई, Etag या if-match हेडर का इस्तेमाल करके अनुरोधों को कैप्चर करती है.

{
    "allowed": true,
    "bytes": 13,
    "millis": 116,
    "name": "rest-transaction",
    "path": [],
    "timestamp": 1484775917216
}

आराम के समय का अपडेट

REST API से किए जाने वाले अपडेट से PATCH अनुरोध दिखते हैं.

{
    "allowed": true,
    "bytes": 5,
    "millis": 11,
    "name": "rest-update",
    "path": [
        "baz",
        "mar"
    ],
    "timestamp": 1484775969930
}

on-disconnect-put

इन कार्रवाइयों में, onDisconnect लिसनर को ऑपरेशन लिखने के लिए जोड़ा जाता है. उदाहरण के लिए, जब onDisconnect().setValue() इस्तेमाल किया जाता है.

{
    "allowed": true,
    "bytes": 4,
    "millis": 2,
    "name": "on-disconnect-put",
    "path": [
        "baz",
        "mar"
    ],
    "timestamp": 1484775969930
}

on-disconnect-update

इन कार्रवाइयों में, onDisconnect लिसनर को जोड़कर, दिए गए ऑपरेशन को अपडेट किया जाता है. उदाहरण के लिए, जब onDisconnect().updateChildren() इस्तेमाल किया जाता है.

{
    "allowed": true,
    "bytes": 4,
    "millis": 2,
    "name": "on-disconnect-update",
    "path": [
        "baz",
        "mar"
    ],
    "timestamp": 1484775969930
}

डिसकनेक्ट होने पर रद्द करें

ये कार्रवाइयां, डिसकनेक्ट करने वाले लिसनर को हटाने से जुड़ी होती हैं. उदाहरण के लिए, जब onDisconnect().set().cancel() इस्तेमाल किया जाता है.

{
    "millis": 2,
    "name": "on-disconnect-cancel",
    "path": [
        "baz",
        "mar"
    ],
    "timestamp": 1484775969930
}

run-on-disconnect

ये कार्रवाइयां, onDisconnect को सुनने वालों को ट्रिगर करती हैं. जब कोई रीयल टाइम क्लाइंट, कम से कम एक onDisconnectलिसनर जोड़ने के बाद डिसकनेक्ट करता है, तो प्रोफ़ाइलर एक run-on-disconnect कार्रवाई को रिकॉर्ड करता है. इसमें, ट्रिगर किए गए सभी onDisconnect लिसनर के एग्रीगेट किए गए बाइट और समय की जानकारी होती है.

{
    "bytes": 4,
    "millis": 2,
    "name": "run-on-disconnect",
    "timestamp": 1484775969930
}