Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(65)

Side by Side Diff: webrtc/logging/rtc_event_log/rtc_event_log.cc

Issue 3007473002: Make RtcEventLogImpl to use a TaskQueue instead of a helper-thread (Closed)
Patch Set: . Created 3 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 /* 1 /*
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 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 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 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
11 #include "webrtc/logging/rtc_event_log/rtc_event_log.h" 11 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
12 12
13 #include <atomic>
14 #include <deque>
15 #include <functional>
13 #include <limits> 16 #include <limits>
17 #include <memory>
14 #include <utility> 18 #include <utility>
15 #include <vector> 19 #include <vector>
16 20
17 #include "webrtc/logging/rtc_event_log/rtc_event_log_helper_thread.h"
18 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_networ k_adaptor.h" 21 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_networ k_adaptor.h"
19 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h" 22 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
20 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" 23 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
21 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" 24 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
22 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h" 25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
23 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h" 26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
24 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h" 27 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h" 28 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h" 29 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
27 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h" 30 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h"
28 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" 31 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
29 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h" 32 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
30 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h" 33 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
31 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h" 34 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
32 #include "webrtc/rtc_base/atomicops.h"
33 #include "webrtc/rtc_base/checks.h" 35 #include "webrtc/rtc_base/checks.h"
34 #include "webrtc/rtc_base/constructormagic.h" 36 #include "webrtc/rtc_base/constructormagic.h"
35 #include "webrtc/rtc_base/event.h" 37 #include "webrtc/rtc_base/event.h"
38 #include "webrtc/rtc_base/ignore_wundef.h"
36 #include "webrtc/rtc_base/logging.h" 39 #include "webrtc/rtc_base/logging.h"
37 #include "webrtc/rtc_base/protobuf_utils.h" 40 #include "webrtc/rtc_base/protobuf_utils.h"
38 #include "webrtc/rtc_base/swap_queue.h" 41 #include "webrtc/rtc_base/ptr_util.h"
39 #include "webrtc/rtc_base/thread_checker.h" 42 #include "webrtc/rtc_base/sequenced_task_checker.h"
43 #include "webrtc/rtc_base/task_queue.h"
44 #include "webrtc/rtc_base/thread_annotations.h"
40 #include "webrtc/rtc_base/timeutils.h" 45 #include "webrtc/rtc_base/timeutils.h"
41 #include "webrtc/system_wrappers/include/file_wrapper.h" 46 #include "webrtc/system_wrappers/include/file_wrapper.h"
47 #include "webrtc/typedefs.h"
42 48
43 #ifdef ENABLE_RTC_EVENT_LOG 49 #ifdef ENABLE_RTC_EVENT_LOG
44 // *.pb.h files are generated at build-time by the protobuf compiler. 50 // *.pb.h files are generated at build-time by the protobuf compiler.
51 RTC_PUSH_IGNORING_WUNDEF()
45 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD 52 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
46 #include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h" 53 #include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
47 #else 54 #else
48 #include "webrtc/logging/rtc_event_log/rtc_event_log.pb.h" 55 #include "webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
49 #endif 56 #endif
57 RTC_POP_IGNORING_WUNDEF()
50 #endif 58 #endif
51 59
52 namespace webrtc { 60 namespace webrtc {
53 61
54 #ifdef ENABLE_RTC_EVENT_LOG 62 #ifdef ENABLE_RTC_EVENT_LOG
55 63
64 namespace {
65 const int kEventsInHistory = 10000;
66
67 bool IsConfigEvent(const rtclog::Event& event) {
68 rtclog::Event_EventType event_type = event.type();
69 return event_type == rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT ||
70 event_type == rtclog::Event::VIDEO_SENDER_CONFIG_EVENT ||
71 event_type == rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT ||
72 event_type == rtclog::Event::AUDIO_SENDER_CONFIG_EVENT;
73 }
74
75 // This class exists because C++11 doesn't allow transferring a unique_ptr to
76 // a lambda (a copy constructor is required).
77 template <typename T>
78 class ResourceOwningTask final : public rtc::QueuedTask {
79 public:
80 ResourceOwningTask(std::unique_ptr<T> resource,
81 std::function<void(std::unique_ptr<T>)> handler)
82 : resource_(std::move(resource)), handler_(handler) {}
83
84 bool Run() override {
85 handler_(std::move(resource_));
86 return true;
87 }
88
89 private:
90 std::unique_ptr<T> resource_;
91 std::function<void(std::unique_ptr<T>)> handler_;
92 };
93 } // namespace
94
56 class RtcEventLogImpl final : public RtcEventLog { 95 class RtcEventLogImpl final : public RtcEventLog {
57 friend std::unique_ptr<RtcEventLog> RtcEventLog::Create(); 96 friend std::unique_ptr<RtcEventLog> RtcEventLog::Create();
58 97
59 public: 98 public:
60 ~RtcEventLogImpl() override; 99 ~RtcEventLogImpl() override;
61 100
62 bool StartLogging(const std::string& file_name, 101 bool StartLogging(const std::string& file_name,
63 int64_t max_size_bytes) override; 102 int64_t max_size_bytes) override;
64 bool StartLogging(rtc::PlatformFile platform_file, 103 bool StartLogging(rtc::PlatformFile platform_file,
65 int64_t max_size_bytes) override; 104 int64_t max_size_bytes) override;
(...skipping 22 matching lines...) Expand all
88 const AudioEncoderRuntimeConfig& config) override; 127 const AudioEncoderRuntimeConfig& config) override;
89 void LogProbeClusterCreated(int id, 128 void LogProbeClusterCreated(int id,
90 int bitrate_bps, 129 int bitrate_bps,
91 int min_probes, 130 int min_probes,
92 int min_bytes) override; 131 int min_bytes) override;
93 void LogProbeResultSuccess(int id, int bitrate_bps) override; 132 void LogProbeResultSuccess(int id, int bitrate_bps) override;
94 void LogProbeResultFailure(int id, 133 void LogProbeResultFailure(int id,
95 ProbeFailureReason failure_reason) override; 134 ProbeFailureReason failure_reason) override;
96 135
97 private: 136 private:
98 // Private constructor to ensure that creation is done by RtcEventLog::Create. 137 void StartLoggingInternal(std::unique_ptr<FileWrapper> file,
99 RtcEventLogImpl(); 138 int64_t max_size_bytes);
139
140 RtcEventLogImpl(); // Creation is done by RtcEventLog::Create.
100 141
101 void StoreEvent(std::unique_ptr<rtclog::Event> event); 142 void StoreEvent(std::unique_ptr<rtclog::Event> event);
102 void LogProbeResult(int id, 143 void LogProbeResult(int id,
103 rtclog::BweProbeResult::ResultType result, 144 rtclog::BweProbeResult::ResultType result,
104 int bitrate_bps); 145 int bitrate_bps);
105 146
106 static volatile int log_count_; 147 // Appends an event to the output protobuf string, returning true on success.
148 // Fails and returns false in case the limit out output size prevents the
149 // event from being added; in this case, the output string is left unchanged.
150 bool AppendEventToString(rtclog::Event* event,
151 ProtoString* output_string) RTC_WARN_UNUSED_RESULT;
107 152
108 // Message queue for passing control messages to the logging thread. 153 void LogToMemory(std::unique_ptr<rtclog::Event> event);
109 SwapQueue<RtcEventLogHelperThread::ControlMessage> message_queue_;
110 154
111 // Message queue for passing events to the logging thread. 155 void StartLogFile();
112 SwapQueue<std::unique_ptr<rtclog::Event> > event_queue_; 156 void LogToFile(std::unique_ptr<rtclog::Event> event);
157 void StopLogFile(int64_t stop_time);
113 158
114 RtcEventLogHelperThread helper_thread_; 159 // Observe a limit on the number of concurrent logs, so as not to run into
115 rtc::ThreadChecker thread_checker_; 160 // OS-imposed limits on open files and/or threads/task-queues.
161 // TODO(eladalon): Known issue - there's a race over |log_count_|.
162 static std::atomic<int> log_count_;
163
164 rtc::SequencedTaskChecker worker_sequence_checker_;
165 rtc::SequencedTaskChecker owner_sequence_checker_;
166
167 // History containing all past configuration events.
168 std::vector<std::unique_ptr<rtclog::Event>> config_history_
169 GUARDED_BY(worker_sequence_checker_);
170
171 // History containing the most recent (non-configuration) events (~ 10 s).
172 std::deque<std::unique_ptr<rtclog::Event>> history_
173 GUARDED_BY(worker_sequence_checker_);
174
175 std::unique_ptr<FileWrapper> file_ GUARDED_BY(worker_sequence_checker_);
176
177 size_t max_size_bytes_ GUARDED_BY(worker_sequence_checker_);
178 size_t written_bytes_ GUARDED_BY(worker_sequence_checker_);
179
180 // Keep this last to ensure it destructs first, or else tasks living on the
181 // queue might access other members after they've been torn down.
182 rtc::TaskQueue task_queue_;
116 183
117 RTC_DISALLOW_COPY_AND_ASSIGN(RtcEventLogImpl); 184 RTC_DISALLOW_COPY_AND_ASSIGN(RtcEventLogImpl);
118 }; 185 };
119 186
120 namespace { 187 namespace {
121 // The functions in this namespace convert enums from the runtime format 188 // The functions in this namespace convert enums from the runtime format
122 // that the rest of the WebRtc project can use, to the corresponding 189 // that the rest of the WebRtc project can use, to the corresponding
123 // serialized enum which is defined by the protobuf. 190 // serialized enum which is defined by the protobuf.
124 191
125 rtclog::VideoReceiveConfig_RtcpMode ConvertRtcpMode(RtcpMode rtcp_mode) { 192 rtclog::VideoReceiveConfig_RtcpMode ConvertRtcpMode(RtcpMode rtcp_mode) {
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
157 return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL; 224 return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL;
158 case kInvalidSendReceiveRatio: 225 case kInvalidSendReceiveRatio:
159 return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO; 226 return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO;
160 case kTimeout: 227 case kTimeout:
161 return rtclog::BweProbeResult::TIMEOUT; 228 return rtclog::BweProbeResult::TIMEOUT;
162 } 229 }
163 RTC_NOTREACHED(); 230 RTC_NOTREACHED();
164 return rtclog::BweProbeResult::SUCCESS; 231 return rtclog::BweProbeResult::SUCCESS;
165 } 232 }
166 233
167 // The RTP and RTCP buffers reserve space for twice the expected number of
168 // sent packets because they also contain received packets.
169 static const int kEventsPerSecond = 1000;
170 static const int kControlMessagesPerSecond = 10;
171 } // namespace 234 } // namespace
172 235
173 volatile int RtcEventLogImpl::log_count_ = 0; 236 std::atomic<int> RtcEventLogImpl::log_count_(0);
174 237
175 // RtcEventLogImpl member functions.
176 RtcEventLogImpl::RtcEventLogImpl() 238 RtcEventLogImpl::RtcEventLogImpl()
177 // Allocate buffers for roughly one second of history. 239 : file_(FileWrapper::Create()),
178 : message_queue_(kControlMessagesPerSecond), 240 max_size_bytes_(std::numeric_limits<decltype(max_size_bytes_)>::max()),
179 event_queue_(kEventsPerSecond), 241 written_bytes_(0),
180 helper_thread_(&message_queue_, &event_queue_), 242 task_queue_("rtc_event_log") {
181 thread_checker_() { 243 worker_sequence_checker_.Detach();
182 thread_checker_.DetachFromThread();
183 } 244 }
184 245
185 RtcEventLogImpl::~RtcEventLogImpl() { 246 RtcEventLogImpl::~RtcEventLogImpl() {
186 // The RtcEventLogHelperThread destructor closes the file 247 RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
187 // and waits for the thread to terminate. 248
188 int count = rtc::AtomicOps::Decrement(&RtcEventLogImpl::log_count_); 249 // If we're logging to the file, this will stop that. Blocking function.
250 StopLogging();
251
252 int count = std::atomic_fetch_sub(&RtcEventLogImpl::log_count_, 1) - 1;
189 RTC_DCHECK_GE(count, 0); 253 RTC_DCHECK_GE(count, 0);
190 } 254 }
191 255
192 bool RtcEventLogImpl::StartLogging(const std::string& file_name, 256 bool RtcEventLogImpl::StartLogging(const std::string& file_name,
193 int64_t max_size_bytes) { 257 int64_t max_size_bytes) {
194 RTC_DCHECK(thread_checker_.CalledOnValidThread()); 258 RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
195 RtcEventLogHelperThread::ControlMessage message; 259
196 message.message_type = RtcEventLogHelperThread::ControlMessage::START_FILE; 260 auto file = rtc::WrapUnique<FileWrapper>(FileWrapper::Create());
197 message.max_size_bytes = max_size_bytes <= 0 261 if (!file->OpenFile(file_name.c_str(), false)) {
198 ? std::numeric_limits<int64_t>::max()
199 : max_size_bytes;
200 message.start_time = rtc::TimeMicros();
201 message.stop_time = std::numeric_limits<int64_t>::max();
202 message.file.reset(FileWrapper::Create());
203 if (!message.file->OpenFile(file_name.c_str(), false)) {
204 LOG(LS_ERROR) << "Can't open file. WebRTC event log not started."; 262 LOG(LS_ERROR) << "Can't open file. WebRTC event log not started.";
205 return false; 263 return false;
206 } 264 }
207 if (!message_queue_.Insert(&message)) { 265
208 LOG(LS_ERROR) << "Message queue full. Can't start logging."; 266 StartLoggingInternal(std::move(file), max_size_bytes);
209 return false; 267
210 }
211 helper_thread_.SignalNewEvent();
212 LOG(LS_INFO) << "Starting WebRTC event log.";
213 return true; 268 return true;
214 } 269 }
215 270
216 bool RtcEventLogImpl::StartLogging(rtc::PlatformFile platform_file, 271 bool RtcEventLogImpl::StartLogging(rtc::PlatformFile platform_file,
217 int64_t max_size_bytes) { 272 int64_t max_size_bytes) {
218 RTC_DCHECK(thread_checker_.CalledOnValidThread()); 273 RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
219 RtcEventLogHelperThread::ControlMessage message; 274
220 message.message_type = RtcEventLogHelperThread::ControlMessage::START_FILE; 275 auto file = rtc::WrapUnique<FileWrapper>(FileWrapper::Create());
221 message.max_size_bytes = max_size_bytes <= 0
222 ? std::numeric_limits<int64_t>::max()
223 : max_size_bytes;
224 message.start_time = rtc::TimeMicros();
225 message.stop_time = std::numeric_limits<int64_t>::max();
226 message.file.reset(FileWrapper::Create());
227 FILE* file_handle = rtc::FdopenPlatformFileForWriting(platform_file); 276 FILE* file_handle = rtc::FdopenPlatformFileForWriting(platform_file);
228 if (!file_handle) { 277 if (!file_handle) {
229 LOG(LS_ERROR) << "Can't open file. WebRTC event log not started."; 278 LOG(LS_ERROR) << "Can't open file. WebRTC event log not started.";
230 // Even though we failed to open a FILE*, the platform_file is still open 279 // Even though we failed to open a FILE*, the platform_file is still open
231 // and needs to be closed. 280 // and needs to be closed.
232 if (!rtc::ClosePlatformFile(platform_file)) { 281 if (!rtc::ClosePlatformFile(platform_file)) {
233 LOG(LS_ERROR) << "Can't close file."; 282 LOG(LS_ERROR) << "Can't close file.";
234 } 283 }
235 return false; 284 return false;
236 } 285 }
237 if (!message.file->OpenFromFileHandle(file_handle)) { 286 if (!file->OpenFromFileHandle(file_handle)) {
238 LOG(LS_ERROR) << "Can't open file. WebRTC event log not started."; 287 LOG(LS_ERROR) << "Can't open file. WebRTC event log not started.";
239 return false; 288 return false;
240 } 289 }
241 if (!message_queue_.Insert(&message)) { 290
242 LOG(LS_ERROR) << "Message queue full. Can't start logging."; 291 StartLoggingInternal(std::move(file), max_size_bytes);
243 return false; 292
244 }
245 helper_thread_.SignalNewEvent();
246 LOG(LS_INFO) << "Starting WebRTC event log.";
247 return true; 293 return true;
248 } 294 }
249 295
250 void RtcEventLogImpl::StopLogging() { 296 void RtcEventLogImpl::StopLogging() {
251 RTC_DCHECK(thread_checker_.CalledOnValidThread()); 297 RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
252 RtcEventLogHelperThread::ControlMessage message; 298
253 message.message_type = RtcEventLogHelperThread::ControlMessage::STOP_FILE;
254 message.stop_time = rtc::TimeMicros();
255 while (!message_queue_.Insert(&message)) {
256 // TODO(terelius): We would like to have a blocking Insert function in the
257 // SwapQueue, but for the time being we will just clear any previous
258 // messages.
259 // Since StopLogging waits for the thread, it is essential that we don't
260 // clear any STOP_FILE messages. To ensure that there is only one call at a
261 // time, we require that all calls to StopLogging are made on the same
262 // thread.
263 LOG(LS_ERROR) << "Message queue full. Clearing queue to stop logging.";
264 message_queue_.Clear();
265 }
266 LOG(LS_INFO) << "Stopping WebRTC event log."; 299 LOG(LS_INFO) << "Stopping WebRTC event log.";
267 helper_thread_.WaitForFileFinished(); 300
301 const int64_t stop_time = rtc::TimeMicros();
302
303 task_queue_.PostTask([this, stop_time]() {
304 RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
nisse-webrtc 2017/08/31 12:09:24 In the case of the worker queue, since we own it,
eladalon 2017/08/31 12:31:32 Done (% RTC_DCHECK_RUN_ON).
305 if (file_->is_open()) {
306 StopLogFile(stop_time);
307 }
308 });
309
310 // Wait for an indication that the previous task, which stops the log file,
311 // has been executed to completion.
312 rtc::Event file_finished(true, false);
313 task_queue_.PostTask([this, &file_finished]() {
314 RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
315 file_finished.Set();
316 });
317 file_finished.Wait(rtc::Event::kForever);
318
319 LOG(LS_INFO) << "WebRTC event log successfully stopped.";
268 } 320 }
269 321
270 void RtcEventLogImpl::LogVideoReceiveStreamConfig( 322 void RtcEventLogImpl::LogVideoReceiveStreamConfig(
271 const rtclog::StreamConfig& config) { 323 const rtclog::StreamConfig& config) {
272 std::unique_ptr<rtclog::Event> event(new rtclog::Event()); 324 std::unique_ptr<rtclog::Event> event(new rtclog::Event());
273 event->set_timestamp_us(rtc::TimeMicros()); 325 event->set_timestamp_us(rtc::TimeMicros());
274 event->set_type(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT); 326 event->set_type(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT);
275 327
276 rtclog::VideoReceiveConfig* receiver_config = 328 rtclog::VideoReceiveConfig* receiver_config =
277 event->mutable_video_receiver_config(); 329 event->mutable_video_receiver_config();
(...skipping 280 matching lines...) Expand 10 before | Expand all | Expand 10 after
558 event->set_type(rtclog::Event::BWE_PROBE_RESULT_EVENT); 610 event->set_type(rtclog::Event::BWE_PROBE_RESULT_EVENT);
559 611
560 auto probe_result = event->mutable_probe_result(); 612 auto probe_result = event->mutable_probe_result();
561 probe_result->set_id(id); 613 probe_result->set_id(id);
562 probe_result->set_result(result); 614 probe_result->set_result(result);
563 if (result == rtclog::BweProbeResult::SUCCESS) 615 if (result == rtclog::BweProbeResult::SUCCESS)
564 probe_result->set_bitrate_bps(bitrate_bps); 616 probe_result->set_bitrate_bps(bitrate_bps);
565 StoreEvent(std::move(event)); 617 StoreEvent(std::move(event));
566 } 618 }
567 619
620 void RtcEventLogImpl::StartLoggingInternal(std::unique_ptr<FileWrapper> file,
621 int64_t max_size_bytes) {
622 LOG(LS_INFO) << "Starting WebRTC event log.";
623
624 max_size_bytes = (max_size_bytes <= 0)
625 ? std::numeric_limits<decltype(max_size_bytes)>::max()
626 : max_size_bytes;
627 auto file_handler = [this,
628 max_size_bytes](std::unique_ptr<FileWrapper> file) {
629 RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
630 if (!file_->is_open()) {
631 max_size_bytes_ = max_size_bytes;
632 file_ = std::move(file);
633 StartLogFile();
634 } else {
635 // Already started. Ignore message and close file handle.
636 file->CloseFile();
637 }
638 };
639 task_queue_.PostTask(rtc::MakeUnique<ResourceOwningTask<FileWrapper>>(
640 std::move(file), file_handler));
641 }
642
568 void RtcEventLogImpl::StoreEvent(std::unique_ptr<rtclog::Event> event) { 643 void RtcEventLogImpl::StoreEvent(std::unique_ptr<rtclog::Event> event) {
569 RTC_DCHECK(event.get() != nullptr); 644 RTC_DCHECK(event);
570 if (!event_queue_.Insert(&event)) { 645
571 LOG(LS_ERROR) << "WebRTC event log queue full. Dropping event."; 646 auto event_handler = [this](std::unique_ptr<rtclog::Event> rtclog_event) {
647 RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
648 if (file_->is_open()) {
649 LogToFile(std::move(rtclog_event));
650 } else {
651 LogToMemory(std::move(rtclog_event));
652 }
653 };
654
655 task_queue_.PostTask(rtc::MakeUnique<ResourceOwningTask<rtclog::Event>>(
656 std::move(event), event_handler));
657 }
658
659 bool RtcEventLogImpl::AppendEventToString(rtclog::Event* event,
660 ProtoString* output_string) {
661 RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
662
663 // Even though we're only serializing a single event during this call, what
664 // we intend to get is a list of events, with a tag and length preceding
665 // each actual event. To produce that, we serialize a list of a single event.
666 // If we later serialize additional events, the resulting ProtoString will
667 // be a proper concatenation of all those events.
668
669 rtclog::EventStream event_stream;
670 event_stream.add_stream();
671
672 // As a tweak, we swap the new event into the event-stream, write that to
673 // file, then swap back. This saves on some copying.
674 rtclog::Event* output_event = event_stream.mutable_stream(0);
675 output_event->Swap(event);
676
677 bool appended;
678 size_t potential_new_size =
679 written_bytes_ + output_string->size() + event_stream.ByteSize();
680 if (potential_new_size <= max_size_bytes_) {
681 event_stream.AppendToString(output_string);
682 appended = true;
683 } else {
684 appended = false;
572 } 685 }
573 helper_thread_.SignalNewEvent(); 686
687 // When the function returns, the original Event will be unchanged.
688 output_event->Swap(event);
689
690 return appended;
691 }
692
693 void RtcEventLogImpl::LogToMemory(std::unique_ptr<rtclog::Event> event) {
694 RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
695 RTC_DCHECK(!file_->is_open());
696
697 if (IsConfigEvent(*event.get())) {
698 config_history_.push_back(std::move(event));
699 } else {
700 history_.push_back(std::move(event));
701 if (history_.size() > kEventsInHistory) {
702 history_.pop_front();
703 }
704 }
705 }
706
707 void RtcEventLogImpl::StartLogFile() {
708 RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
709 RTC_DCHECK(file_->is_open());
710
711 ProtoString output_string;
712
713 // Create and serialize the LOG_START event.
714 // The timestamp used will correspond to when logging has started. The log
715 // may contain events earlier than the LOG_START event. (In general, the
716 // timestamps in the log are not monotonic.)
717 rtclog::Event start_event;
718 start_event.set_timestamp_us(rtc::TimeMicros());
719 start_event.set_type(rtclog::Event::LOG_START);
720 bool appended = AppendEventToString(&start_event, &output_string);
721
722 // Serialize the config information for all old streams, including streams
723 // which were already logged to previous files.
724 for (auto& event : config_history_) {
725 if (!appended) {
726 break;
727 }
728 appended = AppendEventToString(event.get(), &output_string);
729 }
730
731 // Serialize the events in the event queue.
732 while (appended && !history_.empty()) {
733 appended = AppendEventToString(history_.front().get(), &output_string);
734 if (appended) {
735 // Known issue - if writing to the file fails, these events will have
736 // been lost. If we try to open a new file, these events will be missing
737 // from it.
738 history_.pop_front();
739 }
740 }
741
742 // Write to file.
743 if (!file_->Write(output_string.data(), output_string.size())) {
744 LOG(LS_ERROR) << "FileWrapper failed to write WebRtcEventLog file.";
745 // The current FileWrapper implementation closes the file on error.
746 RTC_DCHECK(!file_->is_open());
747 return;
748 }
749 written_bytes_ += output_string.size();
750
751 if (!appended) {
752 RTC_DCHECK(file_->is_open());
753 StopLogFile(rtc::TimeMicros());
754 }
755 }
756
757 void RtcEventLogImpl::LogToFile(std::unique_ptr<rtclog::Event> event) {
758 RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
759 RTC_DCHECK(file_->is_open());
760
761 ProtoString output_string;
762
763 bool appended = AppendEventToString(event.get(), &output_string);
764
765 if (IsConfigEvent(*event.get())) {
766 config_history_.push_back(std::move(event));
767 }
768
769 if (!appended) {
770 RTC_DCHECK(file_->is_open());
771 history_.push_back(std::move(event));
772 StopLogFile(rtc::TimeMicros());
773 return;
774 }
775
776 // Write string to file.
777 if (file_->Write(output_string.data(), output_string.size())) {
778 written_bytes_ += output_string.size();
779 } else {
780 LOG(LS_ERROR) << "FileWrapper failed to write WebRtcEventLog file.";
781 // The current FileWrapper implementation closes the file on error.
782 RTC_DCHECK(!file_->is_open());
783 }
784 }
785
786 void RtcEventLogImpl::StopLogFile(int64_t stop_time) {
787 RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
788 RTC_DCHECK(file_->is_open());
789
790 ProtoString output_string;
791
792 rtclog::Event end_event;
793 end_event.set_timestamp_us(stop_time);
794 end_event.set_type(rtclog::Event::LOG_END);
795 bool appended = AppendEventToString(&end_event, &output_string);
796
797 if (appended) {
798 if (!file_->Write(output_string.data(), output_string.size())) {
799 LOG(LS_ERROR) << "FileWrapper failed to write WebRtcEventLog file.";
800 // The current FileWrapper implementation closes the file on error.
801 RTC_DCHECK(!file_->is_open());
802 }
803 written_bytes_ += output_string.size();
804 }
805
806 max_size_bytes_ = std::numeric_limits<decltype(max_size_bytes_)>::max();
807 written_bytes_ = 0;
808
809 file_->CloseFile();
810 RTC_DCHECK(!file_->is_open());
574 } 811 }
575 812
576 bool RtcEventLog::ParseRtcEventLog(const std::string& file_name, 813 bool RtcEventLog::ParseRtcEventLog(const std::string& file_name,
577 rtclog::EventStream* result) { 814 rtclog::EventStream* result) {
578 char tmp_buffer[1024]; 815 char tmp_buffer[1024];
579 int bytes_read = 0; 816 int bytes_read = 0;
580 std::unique_ptr<FileWrapper> dump_file(FileWrapper::Create()); 817 std::unique_ptr<FileWrapper> dump_file(FileWrapper::Create());
581 if (!dump_file->OpenFile(file_name.c_str(), true)) { 818 if (!dump_file->OpenFile(file_name.c_str(), true)) {
582 return false; 819 return false;
583 } 820 }
584 ProtoString dump_buffer; 821 ProtoString dump_buffer;
585 while ((bytes_read = dump_file->Read(tmp_buffer, sizeof(tmp_buffer))) > 0) { 822 while ((bytes_read = dump_file->Read(tmp_buffer, sizeof(tmp_buffer))) > 0) {
586 dump_buffer.append(tmp_buffer, bytes_read); 823 dump_buffer.append(tmp_buffer, bytes_read);
587 } 824 }
588 dump_file->CloseFile(); 825 dump_file->CloseFile();
589 return result->ParseFromString(dump_buffer); 826 return result->ParseFromString(dump_buffer);
590 } 827 }
591 828
592 #endif // ENABLE_RTC_EVENT_LOG 829 #endif // ENABLE_RTC_EVENT_LOG
593 830
594 // RtcEventLog member functions. 831 // RtcEventLog member functions.
595 std::unique_ptr<RtcEventLog> RtcEventLog::Create() { 832 std::unique_ptr<RtcEventLog> RtcEventLog::Create() {
596 #ifdef ENABLE_RTC_EVENT_LOG 833 #ifdef ENABLE_RTC_EVENT_LOG
834 // TODO(eladalon): Known issue - there's a race over |log_count_| here.
597 constexpr int kMaxLogCount = 5; 835 constexpr int kMaxLogCount = 5;
598 int count = rtc::AtomicOps::Increment(&RtcEventLogImpl::log_count_); 836 int count = 1 + std::atomic_fetch_add(&RtcEventLogImpl::log_count_, 1);
599 if (count > kMaxLogCount) { 837 if (count > kMaxLogCount) {
600 LOG(LS_WARNING) << "Denied creation of additional WebRTC event logs. " 838 LOG(LS_WARNING) << "Denied creation of additional WebRTC event logs. "
601 << count - 1 << " logs open already."; 839 << count - 1 << " logs open already.";
602 rtc::AtomicOps::Decrement(&RtcEventLogImpl::log_count_); 840 std::atomic_fetch_sub(&RtcEventLogImpl::log_count_, 1);
603 return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl()); 841 return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
604 } 842 }
605 return std::unique_ptr<RtcEventLog>(new RtcEventLogImpl()); 843 return std::unique_ptr<RtcEventLog>(new RtcEventLogImpl());
606 #else 844 #else
607 return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl()); 845 return CreateNull();
608 #endif // ENABLE_RTC_EVENT_LOG 846 #endif // ENABLE_RTC_EVENT_LOG
609 } 847 }
610 848
611 std::unique_ptr<RtcEventLog> RtcEventLog::CreateNull() { 849 std::unique_ptr<RtcEventLog> RtcEventLog::CreateNull() {
612 return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl()); 850 return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
613 } 851 }
614 852
615 } // namespace webrtc 853 } // namespace webrtc
OLDNEW
« no previous file with comments | « webrtc/logging/rtc_event_log/rtc_event_log.h ('k') | webrtc/logging/rtc_event_log/rtc_event_log_helper_thread.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698