Add a histogram metric tracking for how long audio RTP packets are sent

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
@@ skipping 28 matching lines @@
 #include "webrtc/rtc_base/basictypes.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/constructormagic.h"
 #include "webrtc/rtc_base/location.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/optional.h"
 #include "webrtc/rtc_base/ptr_util.h"
 #include "webrtc/rtc_base/task_queue.h"
 #include "webrtc/rtc_base/thread_annotations.h"
 #include "webrtc/rtc_base/thread_checker.h"
+#include "webrtc/rtc_base/time_interval.h"
 #include "webrtc/rtc_base/trace_event.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/cpu_info.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/send_delay_stats.h"
 #include "webrtc/video/stats_counter.h"
 #include "webrtc/video/video_receive_stream.h"
@@ skipping 263 matching lines @@
   // from the destructor, and therefore doesn't need any explicit
   // synchronization.
   RateCounter received_bytes_per_second_counter_;
   RateCounter received_audio_bytes_per_second_counter_;
   RateCounter received_video_bytes_per_second_counter_;
   RateCounter received_rtcp_bytes_per_second_counter_;
   rtc::Optional<int64_t> first_received_rtp_audio_ms_;
   rtc::Optional<int64_t> last_received_rtp_audio_ms_;
   rtc::Optional<int64_t> first_received_rtp_video_ms_;
   rtc::Optional<int64_t> last_received_rtp_video_ms_;
+  rtc::TimeInterval sent_rtp_audio_timer_ms_;
 
   // TODO(holmer): Remove this lock once BitrateController no longer calls
   // OnNetworkChanged from multiple threads.
   rtc::CriticalSection bitrate_crit_;
   uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
   uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
   AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
   AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
 
   std::map<std::string, rtc::NetworkRoute> network_routes_;
@@ skipping 161 matching lines @@
 
 void Call::UpdateHistograms() {
   RTC_HISTOGRAM_COUNTS_100000(
       "WebRTC.Call.LifetimeInSeconds",
       (clock_->TimeInMilliseconds() - start_ms_) / 1000);
 }
 
 void Call::UpdateSendHistograms(int64_t first_sent_packet_ms) {
   if (first_sent_packet_ms == -1)
     return;
+  if (!sent_rtp_audio_timer_ms_.Empty()) {
+    RTC_HISTOGRAM_COUNTS_100000(

[pbos-webrtc, 2017/07/13 16:59:45]

Is this code actually intending to track sent RTP from multiple send streams?
Otherwise this could be done entirely in AudioSendStream?

Would it be better for the transport object to track for how long each payload
type is sent, construct the lifetime through there and log lifetime for both
audio or video? E.g. on destruction, report for how long each payload type is
sent.

Also, what should happen when a stream is inactive for 18/20 minutes in the
middle? Is that something we care about? This stats will report that it's
sending for 20 minutes.

+        "WebRTC.Call.TimeSendingAudioRtpPacketsInSeconds",
+        (*sent_rtp_audio_timer_ms_.Last() - *sent_rtp_audio_timer_ms_.First()) /
+            1000);
+  }
   int64_t elapsed_sec =
       (clock_->TimeInMilliseconds() - first_sent_packet_ms) / 1000;
   if (elapsed_sec < metrics::kMinRunTimeInSeconds)
     return;
   const int kMinRequiredPeriodicSamples = 5;
   AggregatedStats send_bitrate_stats =
       estimated_send_bitrate_kbps_counter_.ProcessAndGetStats();
   if (send_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) {
     RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.EstimatedSendBitrateInKbps",
                                 send_bitrate_stats.average);
@@ skipping 118 matching lines @@
   }
   {
     ReadLockScoped read_lock(*receive_crit_);
     for (AudioReceiveStream* stream : audio_receive_streams_) {
       if (stream->config().rtp.local_ssrc == ssrc) {
         stream->AssociateSendStream(nullptr);
       }
     }
   }
   UpdateAggregateNetworkState();
+  const rtc::TimeInterval* stream_active_lifetime =
+      audio_send_stream->GetActiveLifetime();
+  if (!stream_active_lifetime->Empty()) {
+    sent_rtp_audio_timer_ms_.Extend(*stream_active_lifetime->First());
+    sent_rtp_audio_timer_ms_.Extend(*stream_active_lifetime->Last());
+  }
   delete audio_send_stream;
 }
 
 webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
     const webrtc::AudioReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
   RTC_DCHECK_RUN_ON(&configuration_thread_checker_);
   event_log_->LogAudioReceiveStreamConfig(CreateRtcLogStreamConfig(config));
   AudioReceiveStream* receive_stream = new AudioReceiveStream(
       &audio_receiver_controller_, transport_send_->packet_router(), config,
@@ skipping 754 matching lines @@
       (use_send_side_bwe && header.extension.hasTransportSequenceNumber)) {
     receive_side_cc_.OnReceivedPacket(
         packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),
         header);
   }
 }
 
 }  // namespace internal
 
 }  // namespace webrtc