Trace stats in RTCStatsCollector.

webrtc/pc/rtcstatscollector.cc

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/pc/rtcstatscollector.h"
 
 #include <memory>
 #include <sstream>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/mediastreaminterface.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/p2p/base/port.h"
 #include "webrtc/pc/peerconnection.h"
 #include "webrtc/pc/webrtcsession.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/timeutils.h"
+#include "webrtc/rtc_base/trace_event.h"
 
 namespace webrtc {
 
 namespace {
 
+std::string TraceNameFromStatsTypeAndMemberName(const char* stats_type,
+                                                const char* member_name) {
+  return std::string(stats_type) + '.' + member_name;

[tommi, 2017/07/12 15:34:20]

'.' + member_name

by itself is the same as doing |46 + member_name|, so are you counting on
operator order and that the first operator yields a std::string, which will take
override the last + operator?

If that's the case, I would prefer to make it more explicit.  Other than that,
the general idea seems right.

[ehmaldonado_webrtc, 2017/07/12 15:40:32]

Yes, I'm counting on that.
How would I make it more explicit?
Maybe (std::string(stats_type) + '.') + member_name?

[tommi, 2017/07/12 15:44:52]

Yes, that's one way.

Alternatively you could use rtc::sprintfn and reduce the number of heap
allocations to 1 (instead of possibly 3):

char buffer[1024];  // assuming this would always be big enough?
rtc::sprintfn(&buffer[0], sizeof(buffer),
    "%s.%s", stats_type, member_name);
return buffer;

[ehmaldonado_webrtc, 2017/07/12 15:58:27]

Ok, I see :)

Something it's not clear to me, Is it still valid to reference buffer once the
function ends? Isn't it allocated for the duration of the function?

[hbos, 2017/07/12 16:20:15]

It would indeed not be valid to reference it once the function ends. But because
of the return type of our helper function "return buffer;" is implicitly the
same as "return std::string(buffer);". It would copy the characters up to the
first null terminating character into the std::string object that is returned.

Stats dictionaries and member names are quite short and would combined always
fit on much less than a single line. An 80 char buffer would have plenty of
margin.

[ehmaldonado_webrtc, 2017/07/12 16:36:07]

Makes sense.
Done.

+}
+
 std::string RTCCertificateIDFromFingerprint(const std::string& fingerprint) {
   return "RTCCertificate_" + fingerprint;
 }
 
 std::string RTCCodecStatsIDFromDirectionMediaAndPayload(
     bool inbound, bool audio, uint32_t payload_type) {
   // TODO(hbos): The present codec ID assignment is not sufficient to support
   // Unified Plan or unbundled connections in all cases. When we are able to
   // handle multiple m= lines of the same media type (and multiple BaseChannels
   // for the same type is possible?) this needs to be updated to differentiate
@@ skipping 701 matching lines @@
   else
     partial_report_->TakeMembersFrom(partial_report);
   --num_pending_partial_reports_;
   if (!num_pending_partial_reports_) {
     cache_timestamp_us_ = partial_report_timestamp_us_;
     cached_report_ = partial_report_;
     partial_report_ = nullptr;
     channel_name_pairs_.reset();
     track_media_info_map_.reset();
     track_to_id_.clear();
+    for (const RTCStats& stats : *cached_report_) {
+      for (const RTCStatsMemberInterface* member : stats.Members()) {
+        if (member->is_defined()) {
+          TRACE_EVENT_INSTANT2("webrtc_stats",
+                               TraceNameFromStatsTypeAndMemberName(
+                                   stats.type(), member->name()).c_str(),
+                               "value", member->ValueToString(),
+                               "id", stats.id());
+        }
+      }
+    }
     DeliverCachedReport();
   }
 }
 
 void RTCStatsCollector::DeliverCachedReport() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   RTC_DCHECK(!callbacks_.empty());
   RTC_DCHECK(cached_report_);
   for (const rtc::scoped_refptr<RTCStatsCollectorCallback>& callback :
        callbacks_) {
@@ skipping 484 matching lines @@
     const std::string& type) {
   return CandidateTypeToRTCIceCandidateType(type);
 }
 
 const char* DataStateToRTCDataChannelStateForTesting(
     DataChannelInterface::DataState state) {
   return DataStateToRTCDataChannelState(state);
 }
 
 }  // namespace webrtc