इस पेज का अनुवाद Cloud Translation API से किया गया है.

WebRTC: लेगसी getStats() माइग्रेशन गाइड

Henrik Boström

getStats() WebRTC API के पुराने वर्शन को Chrome 117 से हटा दिया जाएगा. इसलिए, इसका इस्तेमाल करने वाले ऐप्लिकेशन को स्टैंडर्ड एपीआई पर माइग्रेट करना होगा. इस लेख में, कोड को माइग्रेट करने का तरीका बताया गया है. साथ ही, यह भी बताया गया है कि अगर इस बदलाव के लिए आपको ज़्यादा समय चाहिए, तो क्या करें.

अब तक, WebRTC getStats() API के दो प्रतिस्पर्धी वर्शन मौजूद हैं. लेगसी getStats() API, जो स्टैंडर्डाइज़ेशन प्रोसेस को पहले से ही अपडेट करता है. साथ ही, यह एक कॉलबैक तर्क लेता है. साथ ही, स्टैंडर्ड और बड़े पैमाने पर काम करने वाला एपीआई दिखाता है, जो प्रॉमिस देता है.

स्टैंडर्ड एपीआई में सुविधाओं के बारे में ज़्यादा जानकारी होती है. इसमें मेट्रिक के बारे में साफ़ तौर पर बताया गया है, जिसे W3C के स्पेसिफ़िकेशन Identifiers for WebRTC's स्टैटिस्ट एपीआई में सार्वजनिक तौर पर दर्ज किया गया है. खास जानकारी में, इस गाइड में दी गई हर मेट्रिक के साथ-साथ और भी जानकारी शामिल है.

Chrome 117 के लेगसी getStats() एपीआई के स्टेबल रिलीज़ चैनल में, अपवाद थ्रो को धीरे-धीरे रोल आउट किया जाएगा. स्टैंडर्ड एपीआई पर ट्रांज़िशन की प्रोसेस को आसान बनाने के लिए, इस गाइड का पालन करें.

ध्यान दें: ऐप्लिकेशन चलने के दौरान, लेगसी और स्टैंडर्ड मेट्रिक की रीयल-टाइम में तुलना की जा सकती है. इसके लिए, अलग टैब में मौजूद chrome://webrtc-internals/ पर जाएं. इसके बाद, ड्रॉप-डाउन टेबल का इस्तेमाल करके, लेगसी या स्टैंडर्ड मेट्रिक चुनें.

लेगसी टाइप बनाम स्टैंडर्ड आंकड़े के टाइप

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

आंकड़ों वाले सभी ऑब्जेक्ट में एक आईडी एट्रिब्यूट होता है, जो कई getStats() कॉल में, मौजूद ऑब्जेक्ट की पहचान करता है. हर बार इस तरीके को कॉल करने पर, एक ही ऑब्जेक्ट का आईडी एक ही होगा. मेट्रिक में बदलाव की दर का हिसाब लगाने के लिए इसका इस्तेमाल किया जाता है. अगले सेक्शन में इसका उदाहरण दिया गया है. आईडी, पहचान फ़ाइलों के बीच का संबंध भी बनाते हैं. उदाहरण के लिए, outbound-rtp आंकड़ों से जुड़ा ऑब्जेक्ट, outbound-rtp.mediaSourceId एट्रिब्यूट के ज़रिए, media-source से जुड़े आंकड़े वाले ऑब्जेक्ट का रेफ़रंस देता है. सभी ...Id संबंध बनाने पर, आपको एक ग्राफ़ मिलता है.

लेगसी एपीआई में, स्टैंडर्ड टाइप के मुताबिक आंकड़े के ये टाइप होते हैं:

लेगसी टाइप	स्टैंडर्ड टाइप
`ssrc`	यह चैनल से जुड़ी `MediaStreamTrack` के बारे में आरटीपी स्ट्रीम और मेट्रिक दिखाता है. इसके स्टैंडर्ड टाइप, `inbound-rtp` (आरटीपी स्ट्रीम और इससे जुड़े रिमोट `MediaStreamTrack` पाने के लिए), `outbound-rtp` (आरटीपी स्ट्रीम भेजने के लिए) और `media-source` (भेजे गए आरटीपी स्ट्रीम से जुड़े लोकल `MediaStreamTrack` मेट्रिक के लिए) हैं. आरटीपी स्ट्रीम से जुड़ी मेट्रिक में उस एन्कोडर या डिकोडर की जानकारी भी होती है जिसका इस्तेमाल आरटीपी स्ट्रीम करता है.
`VideoBwe`	बैंडविड्थ अनुमानित मेट्रिक, टारगेट बिटरेट, एन्कोडर बिटरेट, और असल बिटरेट. इस तरह की मेट्रिक, आरटीपी मेट्रिक (`outbound-rtp` और `inbound-rtp`) और ICE कैंडिडेट पेयर मेट्रिक (`candidate-pair`) का हिस्सा होती हैं.
`googComponent`	परिवहन (ICE और DTLS) के बारे में बताता है. स्टैंडर्ड वर्शन `transport` है.
`localcandidate and remotecandidate`	ICE उम्मीदवार का प्रतिनिधित्व. स्टैंडर्ड वर्शन `local-candidate` और `remote-candidate` है.
`googCandidatePair`	यह ICE कैंडिडेट पेयर के लिए होता है. इसमें लोकल और रिमोट कैंडिडेट, दोनों शामिल होते हैं. स्टैंडर्ड वर्शन `candidate-pair` है.
`googCertificate`	यह ऐसे सर्टिफ़िकेट को दिखाता है जिसका इस्तेमाल डीटीएलएस ट्रांसपोर्ट में किया जाता है. स्टैंडर्ड वर्शन `certificate` है.
`googLibjingleSession`	`RTCPeerConnection` को दिखाता है. हालांकि, इसका कॉन्टेंट स्टैंडर्ड में किसी भी चीज़ से मैप नहीं होता, लेकिन स्टैंडर्ड में `RTCPeerConnection`: `peer-connection` से जुड़ा एक टाइप मौजूद होता है.
लेगसी एपीआई में उपलब्ध नहीं है	इस तरह के आंकड़े, स्टैंडर्ड एपीआई में जोड़े गए हैं. इनमें से कोई लेगसी टाइप उपलब्ध नहीं है: `codec`: एक कोडेक, जिसका इस्तेमाल फ़िलहाल आरटीपी स्ट्रीम में, कोड में बदलने या डिकोड करने के लिए किया जा रहा है. यह उन कोडेक का एक सबसेट है जिनकी एसडीपी में मोल-भाव किया गया है. `remote-inbound-rtp`: रिमोट एंडपॉइंट का इनबाउंड आरटीपी स्ट्रीम, उस आउटबाउंड आरटीपी स्ट्रीम से मेल खाता है जिसे यह एंडपॉइंट भेज रहा है (`outbound-rtp`). इसे रिमोट एंडपॉइंट पर मेज़र किया जाता है. साथ ही, इसे आरटीसीपी रिसीवर रिपोर्ट (आरआर) या आरटीसीपी एक्सटेंडेड रिपोर्ट (एक्सआर) में रिपोर्ट किया जाता है. `remote-outbound-rtp`: रिमोट एंडपॉइंट का आउटबाउंड आरटीपी स्ट्रीम, इस तरह के इनबाउंड आरटीपी स्ट्रीम से मेल खाता है जो इस एंडपॉइंट को मिल रही है (`inbound-rtp`). इसे रिमोट एंडपॉइंट पर मेज़र किया जाता है और आरटीसीपी सेंडर रिपोर्ट (एसआर) में रिपोर्ट किया जाता है. `media-playout`: इनबाउंड आरटीपी स्ट्रीम (`inbound-rtp`) से जुड़े रिमोट `MediaStreamTrack` के प्लेआउट के बारे में मेट्रिक. `data-channel`: `RTCDataChannel` के बारे में बताता है.

लेगसी से स्टैंडर्ड मेट्रिक मैपिंग

इस मैपिंग का मकसद, डेवलपर को यह पता लगाने में मदद करना है कि कौनसी लेगसी मेट्रिक किस स्टैंडर्ड मेट्रिक से मेल खाती है. हालांकि, ध्यान रखें कि इससे जुड़ी मेट्रिक में अलग-अलग इकाइयों का इस्तेमाल हो सकता है या इसे तात्कालिक वैल्यू के बजाय कुल काउंटर के तौर पर दिखाया जा सकता है. मेट्रिक की परिभाषाओं के लिए, खास जानकारी देखें.
स्टैंडर्ड एपीआई, दरों के बजाय कुल काउंटर दिखाना पसंद करता है. इसका मतलब है कि लेगसी एपीआई में, संबंधित दर (उदाहरण के लिए, बिटरेट) पाने के लिए, ऐप्लिकेशन को दो getStats() कॉल के बीच के डेल्टा को ध्यान में रखते हुए औसत दर का हिसाब लगाना होगा. उदाहरण के लिए:

// Periodically (e.g. every second or every 10 seconds)...
const currReport = await pc.getStats();
// Calculate bitrate since the last getStats() call.
// Handling of undefined is omitted for clarity.
const currOutboundRtp = currReport.values().find(s => s.type == 'outbound-rtp');
const prevOutboundRtp = prevReport.get(currOutboundRtp.id);
const deltaBits = (currOutboundRtp.bytesSent - prevOutboundRtp.bytesSent) * 8;
const deltaSeconds = (currOutboundRtp.timestamp - prevOutboundRtp.timestamp) / 1000;
logBitrateMeasurement(deltaBits / deltaSeconds);
// Remember the report for next time.
prevReport = currReport;

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

लेगसी मेट्रिक `googCertificate`	सामान्य पत्राचार `certificate`
`.googFingerprint`	`.fingerprint`
`.googFingerprintAlgorithm`	`.fingerprintAlgorithm`
`.googDerBase64`	`.base64Certificate`

लेगसी मेट्रिक `googComponent`	सामान्य पत्राचार `transport`
`.localCertificateId`	`.localCertificateId`
`.remoteCertificateId`	`.remoteCertificateId`
`.selectedCandidatePairId`	`.selectedCandidatePairId`
`.dtlsCipher`	`.dtlsCipher`
`.srtpCipher`	`.srtpCipher`

लेगसी मेट्रिक `localcandidate`	स्टैंडर्ड पत्राचार `local-candidate` या `candidate-pair`
`.stunKeepaliveRequestsSent`	`candidate-pair.requestsSent` (`candidate-pair.localCandidateId` के ज़रिए `candidate-pair` का रिवर्स लुकअप)
`.portNumber`	`local-candidate.port`
`.networkType`	`local-candidate.networkType`
`.ipAddress`	`local-candidate.address`
`.stunKeepaliveResponsesReceived`	`candidate-pair.responsesReceived`
`.stunKeepaliveRttTotal`	`candidate-pair.totalRoundTripTime`
`.transport`	`local-candidate.protocol`
`.candidateType`	`local-candidate.candidateType`
`.priority`	`local-candidate.priority`

लेगसी मेट्रिक `remotecandidate`	सामान्य पत्राचार `remote-candidate`
ऊपर दिए गए `localcandidate` के समान.	ऊपर दिए गए `local-candidate` के समान.

लेगसी मेट्रिक `googCandidatePair`	सामान्य पत्राचार `candidate-pair`
`.responsesSent`	`candidate-pair.responsesSent`
`.requestsReceived`	`candidate-pair.requestsReceived`
`.googRemoteCandidateType`	`remote-candidate.candidateType` ( `candidate-pair.remoteCandidateId` के ज़रिए `remote-candidate` खोजें)
`.googReadable`	`googReadable` एक बूलियन है जो बताता है कि हमने हाल ही में `candidate-pair.requestsReceived` या `candidate-pair.responsesReceived` को बढ़ाया है या नहीं
`.googLocalAddress`	`local-candidate.address` ( `candidate-pair.localCandidateId` के ज़रिए `local-candidate` खोजें)
`.consentRequestsSent`	`candidate-pair.consentRequestsSent`
`.googTransportType`	`local-candidate.protocol` और `remote-candidate.protocol` के बराबर.
`.googChannelId`	`candidate-pair.transportId`
`.googLocalCandidateType`	`local-candidate.candidateType`
`.googWritable`	`googWritable` एक बूलियन है जो बताता है कि हमने हाल ही में `candidate-pair.responsesReceived` को बढ़ाया है या नहीं
`.googRemoteAddress`	`remote-candidate.address`
`.googRtt`	`candidate-pair.currentRoundTripTime`
`.googActiveConnection`	ऐक्टिव कनेक्शन का मतलब ऐसे कैंडिडेट पेयर से है जिन्हें फ़िलहाल ट्रांसपोर्ट से चुना गया है, जैसे कि `candidate-pair.id == transport.selectedCandidatePairId`
`.packetsDiscardedOnSend`	`candidate-pair.packetsDiscardedOnSend`
`.bytesReceived`	`candidate-pair.bytesReceived`
`.responsesReceived`	`candidate-pair.responsesReceived`
`.remoteCandidateId`	`candidate-pair.remoteCandidateId`
`.localCandidateId`	`candidate-pair.localCandidateId`
`.bytesSent`	`candidate-pair.bytesSent`
`.packetsSent`	`candidate-pair.packetsSent`
`.bytesReceived`	`candidate-pair.bytesReceived`
`.bytesReceived`	`candidate-pair.bytesReceived`

लेगसी मेट्रिक `ssrc`	सामान्य पत्राचार `inbound-rtp`, `outbound-rtp`, `media-source`
`.audioInputLevel`	`media-source.audioLevel`. लेगसी मेट्रिक, [0..32768] की रेंज में है, लेकिन स्टैंडर्ड मेट्रिक की वैल्यू [0..1] की रेंज में है.
`.audioOutputLevel`	`inbound-rtp.audioLevel`. लेगसी मेट्रिक, [0..32768] की रेंज में है, लेकिन स्टैंडर्ड मेट्रिक की वैल्यू [0..1] की रेंज में है.
`.packetsLost`	`inbound-rtp.packetsLost`
`.googTrackId`	लोकल `MediaStreamTrack` के लिए `media-source.trackIdentifier` और रिमोट `MediaStreamTrack` के लिए `inbound-rtp.trackIdentifier`
`.googRtt`	`remote-inbound-rtp.roundTripTime` (`outbound-rtp.remoteId` देखें)
`.googEchoCancellationReturnLossEnhancement`	`inbound-rtp.echoReturnLossEnhancement`
`.googCodecName`	कोडेक का नाम, "टाइप/सब-टाइप" माइम टाइप, `codec.mimeType` का सब-टाइप है (`inbound-rtp.codecId` और `outbound-rtp.codecId` देखें)
`.transportId`	`inbound-rtp.transportId` और `outbound-rtp.transportId`
`.mediaType`	`inbound-rtp.kind` और `outbound-rtp.kind` या `media-source.kind`
`.googEchoCancellationReturnLoss`	`inbound-rtp.echoReturnLoss`
`.totalAudioEnergy`	`inbound-rtp.totalAudioEnergy` और `media-source.totalAudioEnergy`
`ssrc.totalSamplesDuration`	`inbound-rtp.totalSamplesDuration` और `media-source.totalSamplesDuration`
`.ssrc`	`inbound-rtp.ssrc` और `outbound-rtp.ssrc`
`.googJitterReceived`	`inbound-rtp.jitter`
`.packetsSent`	`outbound-rtp.packetsSent`
`.bytesSent`	`outbound-rtp.bytesSent`
`.googContentType`	`inbound-rtp.contentType` और `outbound-rtp.contentType`
`.googFrameWidthInput`	`media-source.width`
`.googFrameHeightInput`	`media-source.height`
`.googFrameRateInput`	`media-source.framesPerSecond`
`.googFrameWidthSent`	`outbound-rtp.frameWidth`
`.googFrameHeightSent`	`outbound-rtp.frameHeight`
`.googFrameRateSent`	भेजा गया FPS (फ़्रेम प्रति सेकंड) `outbound-rtp.framesSent` में होने वाले बदलाव की दर होता है. हालांकि, इसे असल में `outbound-rtp.framesPerSecond` के तौर पर लागू किया जाता है, जो FPS को कोड में बदलता है.
`.googFrameWidthReceived`	`inbound-rtp.frameWidth`
`.googFrameHeightReceived`	`inbound-rtp.frameHeight`
`.googFrameRateDecoded`	`inbound-rtp.framesDecoded` में होने वाले बदलाव की दर
`.googFrameRateOutput`	`inbound-rtp.framesDecoded` - `inbound-rtp.framesDropped` में हुए बदलाव की दर
`.hugeFramesSent`	`outbound-rtp.hugeFramesSent`
`.qpSum`	`inbound-rtp.qpSum` और `outbound-rtp.qpSum`
`.framesEncoded`	`outbound-rtp.framesEncoded`
`.googAvgEncodeMs`	`outbound-rtp.totalEncodeTime` / `outbound-rtp.framesEncoded`
`.codecImplementationName`	`inbound-rtp.decoderImplementation` और `outbound-rtp.encoderImplementation`
`.googCpuLimitedResolution`	सही है अगर `outbound-rtp.qualityLimitationReason == "cpu"`
`.googBandwidthLimitedResolution`	सही है अगर `outbound-rtp.qualityLimitationReason == "bandwidth"`
`.googAdaptationChanges`	लेगसी मेट्रिक में, यह गिनती की जाती है कि `qualityLimitationReason` से जुड़ी वजहों के चलते, रिज़ॉल्यूशन या फ़्रेम रेट में कितनी बार बदलाव हुए हैं. ऐसा अन्य मेट्रिक (उदाहरण के लिए, भेजे जाने वाले रिज़ॉल्यूशन या फ़्रेम रेट की सोर्स रिज़ॉल्यूशन या फ़्रेम रेट से अलग होना) की मदद से किया जा सकता है. हालांकि, सीमित समय के लिए `outbound-rtp.qualityLimitationDurations`, रिज़ॉल्यूशन या फ़्रेम रेट में किए गए बदलावों को फिर से कॉन्फ़िगर करने के मुकाबले ज़्यादा काम की हो सकती है.
`.googNacksReceived`	`inbound-rtp.nackCount`
`.googNacksSent`	`inbound-rtp.nackCount`
`.googPlisReceived`	`inbound-rtp.pliCount`
`.googPlisSent`	`inbound-rtp.pliCount`
`.googFirsReceived`	`inbound-rtp.firCount`
`.googFirsSent`	`inbound-rtp.firCount`
`.googSecondaryDecodedRate`	पैकेट के हाल ही के अनुपात में गड़बड़ी को ठीक करने की सुविधा मौजूद है: `inbound-rtp.fecPacketsReceived` - `inbound-rtp.fecPacketsDiscarded`
`.packetsReceived`	`inbound-rtp.packetsReceived`
`.googJitterBufferMs`	`inbound-rtp.jitterBufferDelay` / `inbound-rtp.jitterBufferEmittedCount`
`.googTargetDelayMs` (वीडियो)	`inbound-rtp.jitterBufferTargetDelay` / `inbound-rtp.jitterBufferEmittedCount`
`.googPreferredJitterBufferMs` (ऑडियो)	`inbound-rtp.jitterBufferTargetDelay` / `inbound-rtp.jitterBufferEmittedCount`
`.googExpandRate`	छिपाए गए सैंपल का हाल ही का अनुपात: `inbound-rtp.concealedSamples` / `inbound-rtp.totalSamplesReceived`
`.googSpeechExpandRate`	स्ट्रीम के बंद होने के दौरान, छिपाए गए सैंपल का हाल ही का अनुपात: (`inbound-rtp.concealedSamples` - `inbound-rtp.silentConcealedSamples`) / `inbound-rtp.concealedSamples`
`.googAccelerateRate`	प्लेआउट की स्पीड बढ़ाने के लिए हटाए गए सैंपल का हाल ही का अनुपात: `inbound-rtp.removedSamplesForAcceleration` / `inbound-rtp.totalSamplesReceived`
`.googPreemptiveExpandRate`	प्लेआउट की रफ़्तार कम करने के लिए, हाल ही में बनाए गए सैंपल का अनुपात: `inbound-rtp.insertedSamplesForDeceleration` / `inbound-rtp.totalSamplesReceived`
`.googSecondaryDiscardedRate`	`inbound-rtp.fecPacketsDiscarded`
`.bytesReceived`	`inbound-rtp.bytesReceived`
`s.googCurrentDelayMs`	`inbound-rtp.jitterBufferDelay` + Media-playout.totalPlayoutDelay
`.googDecodeMs`	`inbound-rtp.totalDecodeTime` / `inbound-rtp.framesDecoded`
`.googTimingFrameInfo`	सिर्फ़ एक गोग मेट्रिक बची है. `inbound-rtp.googTimingFrameInfo`
`.framesDecoded`	`inbound-rtp.framesDecoded`

लेगसी मेट्रिक `VideoBwe`	सामान्य पत्राचार `outbound-rtp` और `candidate-pair`
`.googTargetEncBitrate`	`outbound-rtp.targetBitrate` तात्कालिक मान के रूप में या औसत के रूप में `outbound-rtp.totalEncodedBytesTarget` / `outbound-rtp.framesEncoded`
`.googActualEncBitrate`	एन्कोडर के बनाए गए बाइट, पेलोड बाइट होते हैं. हालांकि, रीट्रांसमिशन को छोड़कर: `outbound-rtp.bytesSent` - `outbound-rtp.retransmittedBytesSent` के बदलाव की दर
`.googBucketDelay`	`outbound-rtp.totalPacketSendDelay` / `outbound-rtp.packetsSent`
`.googTransmitBitrate`	हर आरटीपी स्ट्रीम बिटरेट के लिए `outbound-rtp.headerBytesSent` + `outbound-rtp.bytesSent` के बदलने की दर, हर ICE उम्मीदवार बिटरेट के लिए `candidate-pair.bytesSent` या हर ट्रांसपोर्ट बिटरेट के लिए `transport.bytesSent`
`.googRetransmitBitrate`	`outbound-rtp.retransmittedBytesSent` में होने वाले बदलाव की रेंज
`.googAvailableSendBandwidth`	`candidate-pair.availableOutgoingBitrate`
`.googAvailableReceiveBandwidth`	`candidate-pair.availableIncomingBitrate`

स्टैंडर्ड एपीआई, सिम्युलेट-अवेयर है

अगर सिम्युलेट का इस्तेमाल किया जाता है, तो आपने देखा होगा कि लेगसी एपीआई, सिर्फ़ एक एसएसआरसी की रिपोर्ट करता है. भले ही, तीन अलग-अलग एसएसआरसी पर तीन आरटीपी स्ट्रीम भेजने के लिए सिम्युलेट का इस्तेमाल किया जा रहा हो. उदाहरण के लिए.

स्टैंडर्ड एपीआई इस सीमा को शेयर नहीं करता है और outbound-rtp के आंकड़ों से जुड़े तीन ऑब्जेक्ट दिखाएगा, हर एसएसआरसी के लिए एक. इसका मतलब यह है कि हर आरटीपी स्ट्रीम का अलग-अलग विश्लेषण किया जा सकता है. हालांकि, इसका मतलब यह भी है कि भेजे जाने वाली सभी आरटीपी स्ट्रीम का कुल बिटरेट जानने के लिए, आपको इन्हें खुद ही इकट्ठा करना होगा.

दूसरी ओर, scalabilityMode API के ज़रिए कॉन्फ़िगर की गई कई जगह की जानकारी वाली SVC स्ट्रीम या आरटीपी स्ट्रीम, अब भी एक outbound-rtp के तौर पर दिखती हैं, क्योंकि इन्हें एक एसएसआरसी पर भेजा जाता है.

अगर आपको माइग्रेशन के लिए ज़्यादा समय चाहिए

Chrome 117 में मौजूद लेगसी एपीआई को हटाने पर, उसका इस्तेमाल करने से अपवाद जनरेट होगा. अगर समय पर कोड को माइग्रेट नहीं किया जा सकता, तो RTCPeerConnection कॉलबैक पर आधारित getStats() एपीआई का ऑरिजिन ट्रायल, रजिस्टर की गई वेबसाइटों को माइग्रेट करने के लिए ज़्यादा समय देता है. ऑरिजिन ट्रायल टोकन के साथ, हो सकता है कि लेगसी getStats() एपीआई का इस्तेमाल Chrome 121 तक किया जाता रहे.