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 RTCCertificateIDFromFingerprint(const std::string& fingerprint) {
   return "RTCCertificate_" + fingerprint;
 }
 
 std::string RTCCodecStatsIDFromDirectionMediaAndPayload(
@@ skipping 386 matching lines @@
       video_track, video_track_stats.get());
   video_track_stats->remote_source = false;
   video_track_stats->detached = false;
   video_track_stats->frame_width = static_cast<uint32_t>(
       video_sender_info.send_frame_width);
   video_track_stats->frame_height = static_cast<uint32_t>(
       video_sender_info.send_frame_height);
   // TODO(hbos): Will reduce this by frames dropped due to congestion control
   // when available. crbug.com/659137
   video_track_stats->frames_sent = video_sender_info.frames_encoded;
+  TRACE_EVENT2("webrtc_stats", "sent_frame_width",

[tommi, 2017/07/10 20:43:23]

It would be good to add some context for why these are being traced here and how
it can/should be used. Same below (you could refer to a comment here from the
other places)

+               "value", video_track_stats->frame_width.ValueToString(),
+               "ssrc", video_sender_info.ssrc());
+  TRACE_EVENT2("webrtc_stats", "sent_frame_height",
+               "value", video_track_stats->frame_height.ValueToString(),
+               "ssrc", video_sender_info.ssrc());
+  TRACE_EVENT2("webrtc_stats", "frames_sent",
+               "value", video_track_stats->frames_sent.ValueToString(),
+               "ssrc", video_sender_info.ssrc());
   return video_track_stats;
 }
 
 std::unique_ptr<RTCMediaStreamTrackStats>
 ProduceMediaStreamTrackStatsFromVideoReceiverInfo(
     int64_t timestamp_us,
     const VideoTrackInterface& video_track,
     const cricket::VideoReceiverInfo& video_receiver_info) {
   std::unique_ptr<RTCMediaStreamTrackStats> video_track_stats(
       new RTCMediaStreamTrackStats(
           RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
               false, MediaStreamTrackInterface::kVideoKind, video_track.id(),
               video_receiver_info.ssrc()),
           timestamp_us,
           RTCMediaStreamTrackKind::kVideo));
   SetMediaStreamTrackStatsFromMediaStreamTrackInterface(
       video_track, video_track_stats.get());
   video_track_stats->remote_source = true;
   video_track_stats->detached = false;
   if (video_receiver_info.frame_width > 0 &&
       video_receiver_info.frame_height > 0) {
     video_track_stats->frame_width = static_cast<uint32_t>(
         video_receiver_info.frame_width);
     video_track_stats->frame_height = static_cast<uint32_t>(
         video_receiver_info.frame_height);
+    TRACE_EVENT2("webrtc_stats", "received_frame_width",
+                 "value", video_track_stats->frame_width.ValueToString(),
+                 "ssrc", video_receiver_info.ssrc());
+    TRACE_EVENT2("webrtc_stats", "received_frame_height",
+                 "value", video_track_stats->frame_width.ValueToString(),
+                 "ssrc", video_receiver_info.ssrc());
   }
   video_track_stats->frames_received = video_receiver_info.frames_received;
   // TODO(hbos): When we support receiving simulcast, this should be the total
   // number of frames correctly decoded, independent of which SSRC it was
   // received from. Since we don't support that, this is correct and is the same
   // value as "RTCInboundRTPStreamStats.framesDecoded". crbug.com/659137
   video_track_stats->frames_decoded = video_receiver_info.frames_decoded;
   RTC_DCHECK_GE(video_receiver_info.frames_received,
                 video_receiver_info.frames_rendered);
   video_track_stats->frames_dropped = video_receiver_info.frames_received -
                                       video_receiver_info.frames_rendered;
+  TRACE_EVENT2("webrtc_stats", "frames_received",
+               "value", video_track_stats->frames_received.ValueToString(),
+               "ssrc", video_receiver_info.ssrc());
+  TRACE_EVENT2("webrtc_stats", "frames_decoded",
+               "value", video_track_stats->frames_decoded.ValueToString(),
+               "ssrc", video_receiver_info.ssrc());
+  TRACE_EVENT2("webrtc_stats", "frames_dropped",
+               "value", video_track_stats->frames_dropped.ValueToString(),
+               "ssrc", video_receiver_info.ssrc());

[hbos, 2017/07/11 13:37:13]

The "ssrc" is not a identifier of this report, you should use id() instead, and
dictionary type is probably of interest. See dictionaries in spec
https://w3c.github.io/webrtc-stats/#stats-dictionaries or rtcstats_objects.h.

See other comment, I think you want to trace by these categories:

getStats API / stats dictionary type / stats object id / member name / member
value
e.g. "getStats" / "track" / "xxx" / "famesDropped" / "10"

   return video_track_stats;
 }
 
 void ProduceMediaStreamAndTrackStats(
     int64_t timestamp_us,
     const TrackMediaInfoMap& track_media_info_map,
     rtc::scoped_refptr<StreamCollectionInterface> streams,
     bool is_local,
     RTCStatsReport* report) {
   // TODO(hbos): When "AddTrack" is implemented we should iterate tracks to
@@ skipping 263 matching lines @@
     partial_report_ = partial_report;
   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();

[hbos, 2017/07/11 13:37:13]

Reports are produced asynchronously on different threads as "partial reports"
and merged into the final stats report containing all the stats. On this line,
|cached_report_| is the result of a newly completed getStats call.

If the point of tracing is to deliver a the values of all stats that are
calculated you can loop through cached_report_ here instead of manually adding
tracing information to each member explicitly.

for (const RTCStats& stats : *cached_report_) {
  for (const RTCStatsMemberInterface* member : stats.Members()) {
    if (member->is_defined()) {
      ...
    } else {
      // if a member does not have a value set it is said to be undefined
      // you could trace it as "undefined" or you could skip tracing it.
    }
  }
}

stats.type() is the dictionary type, e.g. "track" for
RTCMediaStreamTrackStats[1].
stats.id() is a string id that uniquely identifies this stats object (id is same
across multiple getStats call if the stats are for the same component).
member is a dictionary member of the stats, this is a key-value. See name(),
ValueToString() and cast_to()

You can a member to RTCStatsMember<T> where T is the value type corresponding to
type() (e.g. uint32_t or std::vector<std::string>) if you don't want to lose
type-information, otherwise just ValueToString

This gives you all stats values. The stack trace is the same for all of them
though, but if you want to measure call time then you should probably trace
ProducePartialResultsOn...Thread methods instead, or the lower layer components
that do the actual stats collecting (that would be complicated) that this file
copies from.

[1] https://w3c.github.io/webrtc-stats/#rtcstatstype-str*

     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