getStats()
WebRTC API के पुराने वर्शन को Chrome 117 से हटा दिया जाएगा. इसलिए, इसका इस्तेमाल करने वाले ऐप्लिकेशन को स्टैंडर्ड एपीआई पर माइग्रेट करना होगा. इस लेख में, कोड को माइग्रेट करने का तरीका बताया गया है. साथ ही, यह भी बताया गया है कि अगर इस बदलाव के लिए आपको ज़्यादा समय चाहिए, तो क्या करें.
अब तक, WebRTC getStats()
API के दो प्रतिस्पर्धी वर्शन मौजूद हैं. लेगसी getStats() API, जो स्टैंडर्डाइज़ेशन प्रोसेस को पहले से ही अपडेट करता है. साथ ही, यह एक कॉलबैक तर्क लेता है. साथ ही, स्टैंडर्ड और बड़े पैमाने पर काम करने वाला एपीआई दिखाता है, जो प्रॉमिस देता है.
स्टैंडर्ड एपीआई में सुविधाओं के बारे में ज़्यादा जानकारी होती है. इसमें मेट्रिक के बारे में साफ़ तौर पर बताया गया है, जिसे W3C के स्पेसिफ़िकेशन Identifiers for WebRTC's स्टैटिस्ट एपीआई में सार्वजनिक तौर पर दर्ज किया गया है. खास जानकारी में, इस गाइड में दी गई हर मेट्रिक के साथ-साथ और भी जानकारी शामिल है.
Chrome 117 के लेगसी getStats()
एपीआई के स्टेबल रिलीज़ चैनल में, अपवाद थ्रो को धीरे-धीरे रोल आउट किया जाएगा. स्टैंडर्ड एपीआई पर ट्रांज़िशन की प्रोसेस को आसान बनाने के लिए, इस गाइड का पालन करें.
लेगसी टाइप बनाम स्टैंडर्ड आंकड़े के टाइप
मानक आंकड़ों के टाइप की पूरी सूची, स्पेसिफ़िकेशन में मौजूद 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 से जुड़ा एक टाइप मौजूद होता है. |
लेगसी एपीआई में उपलब्ध नहीं है |
इस तरह के आंकड़े, स्टैंडर्ड एपीआई में जोड़े गए हैं. इनमें से कोई लेगसी टाइप उपलब्ध नहीं है:
|
लेगसी से स्टैंडर्ड मेट्रिक मैपिंग
इस मैपिंग का मकसद, डेवलपर को यह पता लगाने में मदद करना है कि कौनसी लेगसी मेट्रिक किस स्टैंडर्ड मेट्रिक से मेल खाती है. हालांकि, ध्यान रखें कि इससे जुड़ी मेट्रिक में अलग-अलग इकाइयों का इस्तेमाल हो सकता है या इसे तात्कालिक वैल्यू के बजाय कुल काउंटर के तौर पर दिखाया जा सकता है. मेट्रिक की परिभाषाओं के लिए, खास जानकारी देखें.
स्टैंडर्ड एपीआई, दरों के बजाय कुल काउंटर दिखाना पसंद करता है. इसका मतलब है कि लेगसी एपीआई में, संबंधित दर (उदाहरण के लिए, बिटरेट) पाने के लिए, ऐप्लिकेशन को दो 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
|
|
.framesEncoded
|
outbound-rtp.framesEncoded
|
.googAvgEncodeMs
|
|
.codecImplementationName
|
|
.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 तक किया जाता रहे.