hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2016 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #ifndef PC_RTCSTATSCOLLECTOR_H_ |
| 12 | #define PC_RTCSTATSCOLLECTOR_H_ |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 13 | |
hbos | 2fa7c67 | 2016-10-24 04:00:05 -0700 | [diff] [blame] | 14 | #include <map> |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 15 | #include <memory> |
hbos | 82ebe02 | 2016-11-14 01:41:09 -0800 | [diff] [blame] | 16 | #include <set> |
Steve Anton | 36b29d1 | 2017-10-30 09:57:42 -0700 | [diff] [blame] | 17 | #include <string> |
hbos | c82f2e1 | 2016-09-05 01:36:50 -0700 | [diff] [blame] | 18 | #include <vector> |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 19 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 20 | #include "api/optional.h" |
| 21 | #include "api/stats/rtcstats_objects.h" |
| 22 | #include "api/stats/rtcstatscollectorcallback.h" |
| 23 | #include "api/stats/rtcstatsreport.h" |
| 24 | #include "call/call.h" |
| 25 | #include "media/base/mediachannel.h" |
| 26 | #include "pc/datachannel.h" |
Steve Anton | 2d8609c | 2018-01-23 16:38:46 -0800 | [diff] [blame] | 27 | #include "pc/peerconnectioninternal.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 28 | #include "pc/trackmediainfomap.h" |
| 29 | #include "rtc_base/asyncinvoker.h" |
| 30 | #include "rtc_base/refcount.h" |
| 31 | #include "rtc_base/scoped_ref_ptr.h" |
| 32 | #include "rtc_base/sigslot.h" |
| 33 | #include "rtc_base/sslidentity.h" |
| 34 | #include "rtc_base/timeutils.h" |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 35 | |
| 36 | namespace webrtc { |
| 37 | |
hbos | c82f2e1 | 2016-09-05 01:36:50 -0700 | [diff] [blame] | 38 | // All public methods of the collector are to be called on the signaling thread. |
| 39 | // Stats are gathered on the signaling, worker and network threads |
| 40 | // asynchronously. The callback is invoked on the signaling thread. Resulting |
| 41 | // reports are cached for |cache_lifetime_| ms. |
hbos | 82ebe02 | 2016-11-14 01:41:09 -0800 | [diff] [blame] | 42 | class RTCStatsCollector : public virtual rtc::RefCountInterface, |
| 43 | public sigslot::has_slots<> { |
hbos | c82f2e1 | 2016-09-05 01:36:50 -0700 | [diff] [blame] | 44 | public: |
| 45 | static rtc::scoped_refptr<RTCStatsCollector> Create( |
Steve Anton | 2d8609c | 2018-01-23 16:38:46 -0800 | [diff] [blame] | 46 | PeerConnectionInternal* pc, |
hbos | 0e6758d | 2016-08-31 07:57:36 -0700 | [diff] [blame] | 47 | int64_t cache_lifetime_us = 50 * rtc::kNumMicrosecsPerMillisec); |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 48 | |
| 49 | // Gets a recent stats report. If there is a report cached that is still fresh |
| 50 | // it is returned, otherwise new stats are gathered and returned. A report is |
| 51 | // considered fresh for |cache_lifetime_| ms. const RTCStatsReports are safe |
| 52 | // to use across multiple threads and may be destructed on any thread. |
hbos | c82f2e1 | 2016-09-05 01:36:50 -0700 | [diff] [blame] | 53 | void GetStatsReport(rtc::scoped_refptr<RTCStatsCollectorCallback> callback); |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 54 | // Clears the cache's reference to the most recent stats report. Subsequently |
| 55 | // calling |GetStatsReport| guarantees fresh stats. |
| 56 | void ClearCachedStatsReport(); |
| 57 | |
hbos | b78306a | 2016-12-19 05:06:57 -0800 | [diff] [blame] | 58 | // If there is a |GetStatsReport| requests in-flight, waits until it has been |
| 59 | // completed. Must be called on the signaling thread. |
| 60 | void WaitForPendingRequest(); |
| 61 | |
hbos | c82f2e1 | 2016-09-05 01:36:50 -0700 | [diff] [blame] | 62 | protected: |
Steve Anton | 2d8609c | 2018-01-23 16:38:46 -0800 | [diff] [blame] | 63 | RTCStatsCollector(PeerConnectionInternal* pc, int64_t cache_lifetime_us); |
hbos | b78306a | 2016-12-19 05:06:57 -0800 | [diff] [blame] | 64 | ~RTCStatsCollector(); |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 65 | |
hbos | c82f2e1 | 2016-09-05 01:36:50 -0700 | [diff] [blame] | 66 | // Stats gathering on a particular thread. Calls |AddPartialResults| before |
| 67 | // returning. Virtual for the sake of testing. |
| 68 | virtual void ProducePartialResultsOnSignalingThread(int64_t timestamp_us); |
hbos | c82f2e1 | 2016-09-05 01:36:50 -0700 | [diff] [blame] | 69 | virtual void ProducePartialResultsOnNetworkThread(int64_t timestamp_us); |
| 70 | |
| 71 | // Can be called on any thread. |
| 72 | void AddPartialResults( |
| 73 | const rtc::scoped_refptr<RTCStatsReport>& partial_report); |
| 74 | |
| 75 | private: |
hbos | 2fa7c67 | 2016-10-24 04:00:05 -0700 | [diff] [blame] | 76 | struct CertificateStatsPair { |
| 77 | std::unique_ptr<rtc::SSLCertificateStats> local; |
| 78 | std::unique_ptr<rtc::SSLCertificateStats> remote; |
| 79 | }; |
| 80 | |
hbos | c82f2e1 | 2016-09-05 01:36:50 -0700 | [diff] [blame] | 81 | void AddPartialResults_s(rtc::scoped_refptr<RTCStatsReport> partial_report); |
| 82 | void DeliverCachedReport(); |
| 83 | |
hbos | ab9f6e4 | 2016-10-07 02:18:47 -0700 | [diff] [blame] | 84 | // Produces |RTCCertificateStats|. |
hbos | df6075a | 2016-12-19 04:58:02 -0800 | [diff] [blame] | 85 | void ProduceCertificateStats_n( |
hbos | 2fa7c67 | 2016-10-24 04:00:05 -0700 | [diff] [blame] | 86 | int64_t timestamp_us, |
| 87 | const std::map<std::string, CertificateStatsPair>& transport_cert_stats, |
hbos | 6ab97ce | 2016-10-03 14:16:56 -0700 | [diff] [blame] | 88 | RTCStatsReport* report) const; |
hbos | 0adb828 | 2016-11-23 02:32:06 -0800 | [diff] [blame] | 89 | // Produces |RTCCodecStats|. |
hbos | df6075a | 2016-12-19 04:58:02 -0800 | [diff] [blame] | 90 | void ProduceCodecStats_n( |
hbos | 84abeb1 | 2017-01-16 06:16:44 -0800 | [diff] [blame] | 91 | int64_t timestamp_us, const TrackMediaInfoMap& track_media_info_map, |
hbos | 0adb828 | 2016-11-23 02:32:06 -0800 | [diff] [blame] | 92 | RTCStatsReport* report) const; |
hbos | cc555c5 | 2016-10-18 12:48:31 -0700 | [diff] [blame] | 93 | // Produces |RTCDataChannelStats|. |
| 94 | void ProduceDataChannelStats_s( |
| 95 | int64_t timestamp_us, RTCStatsReport* report) const; |
hbos | c47a0c3 | 2016-10-11 14:54:49 -0700 | [diff] [blame] | 96 | // Produces |RTCIceCandidatePairStats| and |RTCIceCandidateStats|. |
hbos | df6075a | 2016-12-19 04:58:02 -0800 | [diff] [blame] | 97 | void ProduceIceCandidateAndPairStats_n( |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 98 | int64_t timestamp_us, |
Steve Anton | 5dfde18 | 2018-02-06 10:34:40 -0800 | [diff] [blame^] | 99 | const std::map<std::string, cricket::TransportStats>& |
| 100 | transport_stats_by_name, |
hbos | 338f78a | 2017-02-07 06:41:21 -0800 | [diff] [blame] | 101 | const cricket::VideoMediaInfo* video_media_info, |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 102 | const Call::Stats& call_stats, |
hbos | ab9f6e4 | 2016-10-07 02:18:47 -0700 | [diff] [blame] | 103 | RTCStatsReport* report) const; |
hbos | 09bc128 | 2016-11-08 06:29:22 -0800 | [diff] [blame] | 104 | // Produces |RTCMediaStreamStats| and |RTCMediaStreamTrackStats|. |
| 105 | void ProduceMediaStreamAndTrackStats_s( |
| 106 | int64_t timestamp_us, RTCStatsReport* report) const; |
hbos | ab9f6e4 | 2016-10-07 02:18:47 -0700 | [diff] [blame] | 107 | // Produces |RTCPeerConnectionStats|. |
hbos | 6ab97ce | 2016-10-03 14:16:56 -0700 | [diff] [blame] | 108 | void ProducePeerConnectionStats_s( |
| 109 | int64_t timestamp_us, RTCStatsReport* report) const; |
hbos | eeafe94 | 2016-11-01 03:00:17 -0700 | [diff] [blame] | 110 | // Produces |RTCInboundRTPStreamStats| and |RTCOutboundRTPStreamStats|. |
Steve Anton | 5dfde18 | 2018-02-06 10:34:40 -0800 | [diff] [blame^] | 111 | void ProduceRTPStreamStats_n( |
| 112 | int64_t timestamp_us, |
| 113 | const std::map<std::string, std::string>& transport_names_by_mid, |
| 114 | const TrackMediaInfoMap& track_media_info_map, |
| 115 | RTCStatsReport* report) const; |
hbos | 2fa7c67 | 2016-10-24 04:00:05 -0700 | [diff] [blame] | 116 | // Produces |RTCTransportStats|. |
hbos | df6075a | 2016-12-19 04:58:02 -0800 | [diff] [blame] | 117 | void ProduceTransportStats_n( |
Steve Anton | 5dfde18 | 2018-02-06 10:34:40 -0800 | [diff] [blame^] | 118 | int64_t timestamp_us, |
| 119 | const std::map<std::string, cricket::TransportStats>& |
| 120 | transport_stats_by_name, |
hbos | 2fa7c67 | 2016-10-24 04:00:05 -0700 | [diff] [blame] | 121 | const std::map<std::string, CertificateStatsPair>& transport_cert_stats, |
| 122 | RTCStatsReport* report) const; |
| 123 | |
| 124 | // Helper function to stats-producing functions. |
| 125 | std::map<std::string, CertificateStatsPair> |
Steve Anton | 5dfde18 | 2018-02-06 10:34:40 -0800 | [diff] [blame^] | 126 | PrepareTransportCertificateStats_n( |
| 127 | const std::map<std::string, cricket::TransportStats>& |
| 128 | transport_stats_by_name) const; |
hbos | 84abeb1 | 2017-01-16 06:16:44 -0800 | [diff] [blame] | 129 | std::unique_ptr<TrackMediaInfoMap> PrepareTrackMediaInfoMap_s() const; |
| 130 | std::map<MediaStreamTrackInterface*, std::string> PrepareTrackToID_s() const; |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 131 | |
hbos | 82ebe02 | 2016-11-14 01:41:09 -0800 | [diff] [blame] | 132 | // Slots for signals (sigslot) that are wired up to |pc_|. |
| 133 | void OnDataChannelCreated(DataChannel* channel); |
| 134 | // Slots for signals (sigslot) that are wired up to |channel|. |
| 135 | void OnDataChannelOpened(DataChannel* channel); |
| 136 | void OnDataChannelClosed(DataChannel* channel); |
| 137 | |
Steve Anton | 2d8609c | 2018-01-23 16:38:46 -0800 | [diff] [blame] | 138 | PeerConnectionInternal* const pc_; |
hbos | c82f2e1 | 2016-09-05 01:36:50 -0700 | [diff] [blame] | 139 | rtc::Thread* const signaling_thread_; |
| 140 | rtc::Thread* const worker_thread_; |
| 141 | rtc::Thread* const network_thread_; |
| 142 | rtc::AsyncInvoker invoker_; |
| 143 | |
| 144 | int num_pending_partial_reports_; |
| 145 | int64_t partial_report_timestamp_us_; |
| 146 | rtc::scoped_refptr<RTCStatsReport> partial_report_; |
| 147 | std::vector<rtc::scoped_refptr<RTCStatsCollectorCallback>> callbacks_; |
| 148 | |
hbos | 84abeb1 | 2017-01-16 06:16:44 -0800 | [diff] [blame] | 149 | // Set in |GetStatsReport|, read in |ProducePartialResultsOnNetworkThread| and |
| 150 | // |ProducePartialResultsOnSignalingThread|, reset after work is complete. Not |
| 151 | // passed as arguments to avoid copies. This is thread safe - when we |
| 152 | // set/reset we know there are no pending stats requests in progress. |
Steve Anton | 5dfde18 | 2018-02-06 10:34:40 -0800 | [diff] [blame^] | 153 | std::map<std::string, std::string> transport_names_by_mid_; |
hbos | 84abeb1 | 2017-01-16 06:16:44 -0800 | [diff] [blame] | 154 | std::unique_ptr<TrackMediaInfoMap> track_media_info_map_; |
| 155 | std::map<MediaStreamTrackInterface*, std::string> track_to_id_; |
Steve Anton | 593e325 | 2017-12-15 11:44:48 -0800 | [diff] [blame] | 156 | |
Steve Anton | 5dfde18 | 2018-02-06 10:34:40 -0800 | [diff] [blame^] | 157 | rtc::Optional<std::string> voice_mid_; |
| 158 | rtc::Optional<std::string> video_mid_; |
| 159 | |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 160 | Call::Stats call_stats_; |
hbos | df6075a | 2016-12-19 04:58:02 -0800 | [diff] [blame] | 161 | |
hbos | 0e6758d | 2016-08-31 07:57:36 -0700 | [diff] [blame] | 162 | // A timestamp, in microseconds, that is based on a timer that is |
| 163 | // monotonically increasing. That is, even if the system clock is modified the |
| 164 | // difference between the timer and this timestamp is how fresh the cached |
| 165 | // report is. |
| 166 | int64_t cache_timestamp_us_; |
| 167 | int64_t cache_lifetime_us_; |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 168 | rtc::scoped_refptr<const RTCStatsReport> cached_report_; |
hbos | 82ebe02 | 2016-11-14 01:41:09 -0800 | [diff] [blame] | 169 | |
| 170 | // Data recorded and maintained by the stats collector during its lifetime. |
| 171 | // Some stats are produced from this record instead of other components. |
| 172 | struct InternalRecord { |
| 173 | InternalRecord() : data_channels_opened(0), |
| 174 | data_channels_closed(0) {} |
| 175 | |
| 176 | // The opened count goes up when a channel is fully opened and the closed |
| 177 | // count goes up if a previously opened channel has fully closed. The opened |
| 178 | // count does not go down when a channel closes, meaning (opened - closed) |
| 179 | // is the number of channels currently opened. A channel that is closed |
| 180 | // before reaching the open state does not affect these counters. |
| 181 | uint32_t data_channels_opened; |
| 182 | uint32_t data_channels_closed; |
| 183 | // Identifies by address channels that have been opened, which remain in the |
| 184 | // set until they have been fully closed. |
| 185 | std::set<uintptr_t> opened_data_channels; |
| 186 | }; |
| 187 | InternalRecord internal_record_; |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 188 | }; |
| 189 | |
hbos | cc555c5 | 2016-10-18 12:48:31 -0700 | [diff] [blame] | 190 | const char* CandidateTypeToRTCIceCandidateTypeForTesting( |
| 191 | const std::string& type); |
| 192 | const char* DataStateToRTCDataChannelStateForTesting( |
| 193 | DataChannelInterface::DataState state); |
hbos | ab9f6e4 | 2016-10-07 02:18:47 -0700 | [diff] [blame] | 194 | |
hbos | d565b73 | 2016-08-30 14:04:35 -0700 | [diff] [blame] | 195 | } // namespace webrtc |
| 196 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 197 | #endif // PC_RTCSTATSCOLLECTOR_H_ |