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/stringutils.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) {
+  char buffer[80];
+  rtc::sprintfn(&buffer[0], sizeof(buffer), "%s.%s", stats_type, member_name);

[tommi, 2017/07/12 16:53:03]

You might want to add dchecks for the length of the constants

+  return buffer;
+}
+
 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();
+    // Trace WebRTC Stats when getStats is called on Javascript.
+    // This allows access to WebRTC stats from trace logs. To enable them,
+    // select the "webrtc_stats" category when recording traces.
+    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(),

[tommi, 2017/07/12 16:53:03]

Have you checked if this is a concern?
https://cs.chromium.org/chromium/src/base/trace_event/common/trace_event_comm...

[ehmaldonado_webrtc, 2017/07/12 18:57:10]

Right, I missed that. :(

I think the easiest way would be to trace all events under a single trace name,
something like:

  TRACE_EVENT_INSTANT2("webrtc_stats", "webrtc_stats",
                       "value", member->ValueToString(),
                       "stat_info", "%s.%s.%s" % (
                           stats.name(), member->name(), stats.id())); 

(That's not valid C++, but you get the idea :P)

Otherwise I think we'll have to trace each stat separately, or define lots of
const char* so we can reference them.

What do you think? Maybe I'm missing something.

+                               "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