net/base/net_log.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/net_log.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/time/time.h"
  12 #include "base/values.h"
  13 #include "net/base/net_errors.h"
  14
  15 namespace net {
  16
  17 namespace {
  18
  19 // Returns parameters for logging data transferred events. Includes number of
  20 // bytes transferred and, if the log level indicates bytes should be logged and
  21 // |byte_count| > 0, the bytes themselves.  The bytes are hex-encoded, since
  22 // base::StringValue only supports UTF-8.
  23 base::Value* BytesTransferredCallback(int byte_count,
  24                                       const char* bytes,
  25                                       NetLog::LogLevel log_level) {
  26   base::DictionaryValue* dict = new base::DictionaryValue();
  27   dict->SetInteger("byte_count", byte_count);
  28   if (NetLog::IsLoggingBytes(log_level) && byte_count > 0)
  29     dict->SetString("hex_encoded_bytes", base::HexEncode(bytes, byte_count));
  30   return dict;
  31 }
  32
  33 base::Value* SourceEventParametersCallback(const NetLog::Source source,
  34                                            NetLog::LogLevel /* log_level */) {
  35   if (!source.IsValid())
  36     return NULL;
  37   base::DictionaryValue* event_params = new base::DictionaryValue();
  38   source.AddToEventParameters(event_params);
  39   return event_params;
  40 }
  41
  42 base::Value* NetLogIntegerCallback(const char* name,
  43                                    int value,
  44                                    NetLog::LogLevel /* log_level */) {
  45   base::DictionaryValue* event_params = new base::DictionaryValue();
  46   event_params->SetInteger(name, value);
  47   return event_params;
  48 }
  49
  50 base::Value* NetLogInt64Callback(const char* name,
  51                                  int64 value,
  52                                  NetLog::LogLevel /* log_level */) {
  53   base::DictionaryValue* event_params = new base::DictionaryValue();
  54   event_params->SetString(name, base::Int64ToString(value));
  55   return event_params;
  56 }
  57
  58 base::Value* NetLogStringCallback(const char* name,
  59                                   const std::string* value,
  60                                   NetLog::LogLevel /* log_level */) {
  61   base::DictionaryValue* event_params = new base::DictionaryValue();
  62   event_params->SetString(name, *value);
  63   return event_params;
  64 }
  65
  66 base::Value* NetLogString16Callback(const char* name,
  67                                     const base::string16* value,
  68                                     NetLog::LogLevel /* log_level */) {
  69   base::DictionaryValue* event_params = new base::DictionaryValue();
  70   event_params->SetString(name, *value);
  71   return event_params;
  72 }
  73
  74 }  // namespace
  75
  76 // LoadTimingInfo requires this be 0.
  77 const uint32 NetLog::Source::kInvalidId = 0;
  78
  79 NetLog::Source::Source() : type(SOURCE_NONE), id(kInvalidId) {
  80 }
  81
  82 NetLog::Source::Source(SourceType type, uint32 id) : type(type), id(id) {
  83 }
  84
  85 bool NetLog::Source::IsValid() const {
  86   return id != kInvalidId;
  87 }
  88
  89 void NetLog::Source::AddToEventParameters(
  90     base::DictionaryValue* event_params) const {
  91   base::DictionaryValue* dict = new base::DictionaryValue();
  92   dict->SetInteger("type", static_cast<int>(type));
  93   dict->SetInteger("id", static_cast<int>(id));
  94   event_params->Set("source_dependency", dict);
  95 }
  96
  97 NetLog::ParametersCallback NetLog::Source::ToEventParametersCallback() const {
  98   return base::Bind(&SourceEventParametersCallback, *this);
  99 }
 100
 101 // static
 102 bool NetLog::Source::FromEventParameters(base::Value* event_params,
 103                                          Source* source) {
 104   base::DictionaryValue* dict;
 105   base::DictionaryValue* source_dict;
 106   int source_id;
 107   int source_type;
 108   if (!event_params ||
 109       !event_params->GetAsDictionary(&dict) ||
 110       !dict->GetDictionary("source_dependency", &source_dict) ||
 111       !source_dict->GetInteger("id", &source_id) ||
 112       !source_dict->GetInteger("type", &source_type)) {
 113     *source = Source();
 114     return false;
 115   }
 116
 117   DCHECK_LE(0, source_id);
 118   DCHECK_LT(source_type, NetLog::SOURCE_COUNT);
 119   *source = Source(static_cast<SourceType>(source_type), source_id);
 120   return true;
 121 }
 122
 123 base::Value* NetLog::Entry::ToValue() const {
 124   base::DictionaryValue* entry_dict(new base::DictionaryValue());
 125
 126   entry_dict->SetString("time", TickCountToString(time_));
 127
 128   // Set the entry source.
 129   base::DictionaryValue* source_dict = new base::DictionaryValue();
 130   source_dict->SetInteger("id", source_.id);
 131   source_dict->SetInteger("type", static_cast<int>(source_.type));
 132   entry_dict->Set("source", source_dict);
 133
 134   // Set the event info.
 135   entry_dict->SetInteger("type", static_cast<int>(type_));
 136   entry_dict->SetInteger("phase", static_cast<int>(phase_));
 137
 138   // Set the event-specific parameters.
 139   if (parameters_callback_) {
 140     base::Value* value = parameters_callback_->Run(log_level_);
 141     if (value)
 142       entry_dict->Set("params", value);
 143   }
 144
 145   return entry_dict;
 146 }
 147
 148 base::Value* NetLog::Entry::ParametersToValue() const {
 149   if (parameters_callback_)
 150     return parameters_callback_->Run(log_level_);
 151   return NULL;
 152 }
 153
 154 NetLog::Entry::Entry(
 155     EventType type,
 156     Source source,
 157     EventPhase phase,
 158     base::TimeTicks time,
 159     const ParametersCallback* parameters_callback,
 160     LogLevel log_level)
 161     : type_(type),
 162       source_(source),
 163       phase_(phase),
 164       time_(time),
 165       parameters_callback_(parameters_callback),
 166       log_level_(log_level) {
 167 };
 168
 169 NetLog::Entry::~Entry() {
 170 }
 171
 172 NetLog::ThreadSafeObserver::ThreadSafeObserver() : log_level_(LOG_BASIC),
 173                                                    net_log_(NULL) {
 174 }
 175
 176 NetLog::ThreadSafeObserver::~ThreadSafeObserver() {
 177   // Make sure we aren't watching a NetLog on destruction.  Because the NetLog
 178   // may pass events to each observer on multiple threads, we cannot safely
 179   // stop watching a NetLog automatically from a parent class.
 180   DCHECK(!net_log_);
 181 }
 182
 183 NetLog::LogLevel NetLog::ThreadSafeObserver::log_level() const {
 184   DCHECK(net_log_);
 185   return log_level_;
 186 }
 187
 188 NetLog* NetLog::ThreadSafeObserver::net_log() const {
 189   return net_log_;
 190 }
 191
 192 NetLog::NetLog()
 193     : last_id_(0),
 194       base_log_level_(LOG_NONE),
 195       effective_log_level_(LOG_NONE) {
 196 }
 197
 198 NetLog::~NetLog() {
 199 }
 200
 201 void NetLog::AddGlobalEntry(EventType type) {
 202   AddEntry(type,
 203            Source(net::NetLog::SOURCE_NONE, NextID()),
 204            net::NetLog::PHASE_NONE,
 205            NULL);
 206 }
 207
 208 void NetLog::AddGlobalEntry(
 209     EventType type,
 210     const NetLog::ParametersCallback& parameters_callback) {
 211   AddEntry(type,
 212            Source(net::NetLog::SOURCE_NONE, NextID()),
 213            net::NetLog::PHASE_NONE,
 214            &parameters_callback);
 215 }
 216
 217 uint32 NetLog::NextID() {
 218   return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
 219 }
 220
 221 void NetLog::SetBaseLogLevel(LogLevel log_level) {
 222   base::AutoLock lock(lock_);
 223   base_log_level_ = log_level;
 224
 225   UpdateLogLevel();
 226 }
 227
 228 NetLog::LogLevel NetLog::GetLogLevel() const {
 229   base::subtle::Atomic32 log_level =
 230       base::subtle::NoBarrier_Load(&effective_log_level_);
 231   return static_cast<net::NetLog::LogLevel>(log_level);
 232 }
 233
 234 void NetLog::AddThreadSafeObserver(
 235     net::NetLog::ThreadSafeObserver* observer,
 236     LogLevel log_level) {
 237   base::AutoLock lock(lock_);
 238
 239   DCHECK(!observer->net_log_);
 240   observers_.AddObserver(observer);
 241   observer->net_log_ = this;
 242   observer->log_level_ = log_level;
 243   UpdateLogLevel();
 244 }
 245
 246 void NetLog::SetObserverLogLevel(
 247     net::NetLog::ThreadSafeObserver* observer,
 248     LogLevel log_level) {
 249   base::AutoLock lock(lock_);
 250
 251   DCHECK(observers_.HasObserver(observer));
 252   DCHECK_EQ(this, observer->net_log_);
 253   observer->log_level_ = log_level;
 254   UpdateLogLevel();
 255 }
 256
 257 void NetLog::RemoveThreadSafeObserver(
 258     net::NetLog::ThreadSafeObserver* observer) {
 259   base::AutoLock lock(lock_);
 260
 261   DCHECK(observers_.HasObserver(observer));
 262   DCHECK_EQ(this, observer->net_log_);
 263   observers_.RemoveObserver(observer);
 264   observer->net_log_ = NULL;
 265   UpdateLogLevel();
 266 }
 267
 268 void NetLog::UpdateLogLevel() {
 269   lock_.AssertAcquired();
 270
 271   // Look through all the observers and find the finest granularity
 272   // log level (higher values of the enum imply *lower* log levels).
 273   LogLevel new_effective_log_level = base_log_level_;
 274   ObserverListBase<ThreadSafeObserver>::Iterator it(observers_);
 275   ThreadSafeObserver* observer;
 276   while ((observer = it.GetNext()) != NULL) {
 277     new_effective_log_level =
 278         std::min(new_effective_log_level, observer->log_level());
 279   }
 280   base::subtle::NoBarrier_Store(&effective_log_level_,
 281                                 new_effective_log_level);
 282 }
 283
 284 // static
 285 std::string NetLog::TickCountToString(const base::TimeTicks& time) {
 286   int64 delta_time = (time - base::TimeTicks()).InMilliseconds();
 287   return base::Int64ToString(delta_time);
 288 }
 289
 290 // static
 291 const char* NetLog::EventTypeToString(EventType event) {
 292   switch (event) {
 293 #define EVENT_TYPE(label) case TYPE_ ## label: return #label;
 294 #include "net/base/net_log_event_type_list.h"
 295 #undef EVENT_TYPE
 296     default:
 297       NOTREACHED();
 298       return NULL;
 299   }
 300 }
 301
 302 // static
 303 base::Value* NetLog::GetEventTypesAsValue() {
 304   base::DictionaryValue* dict = new base::DictionaryValue();
 305   for (int i = 0; i < EVENT_COUNT; ++i) {
 306     dict->SetInteger(EventTypeToString(static_cast<EventType>(i)), i);
 307   }
 308   return dict;
 309 }
 310
 311 // static
 312 const char* NetLog::SourceTypeToString(SourceType source) {
 313   switch (source) {
 314 #define SOURCE_TYPE(label) case SOURCE_ ## label: return #label;
 315 #include "net/base/net_log_source_type_list.h"
 316 #undef SOURCE_TYPE
 317     default:
 318       NOTREACHED();
 319       return NULL;
 320   }
 321 }
 322
 323 // static
 324 base::Value* NetLog::GetSourceTypesAsValue() {
 325   base::DictionaryValue* dict = new base::DictionaryValue();
 326   for (int i = 0; i < SOURCE_COUNT; ++i) {
 327     dict->SetInteger(SourceTypeToString(static_cast<SourceType>(i)), i);
 328   }
 329   return dict;
 330 }
 331
 332 // static
 333 const char* NetLog::EventPhaseToString(EventPhase phase) {
 334   switch (phase) {
 335     case PHASE_BEGIN:
 336       return "PHASE_BEGIN";
 337     case PHASE_END:
 338       return "PHASE_END";
 339     case PHASE_NONE:
 340       return "PHASE_NONE";
 341   }
 342   NOTREACHED();
 343   return NULL;
 344 }
 345
 346 // static
 347 bool NetLog::IsLoggingBytes(LogLevel log_level) {
 348   return log_level == NetLog::LOG_ALL;
 349 }
 350
 351 // static
 352 bool NetLog::IsLoggingAllEvents(LogLevel log_level) {
 353   return log_level <= NetLog::LOG_ALL_BUT_BYTES;
 354 }
 355
 356 // static
 357 NetLog::ParametersCallback NetLog::IntegerCallback(const char* name,
 358                                                    int value) {
 359   return base::Bind(&NetLogIntegerCallback, name, value);
 360 }
 361
 362 // static
 363 NetLog::ParametersCallback NetLog::Int64Callback(const char* name,
 364                                                  int64 value) {
 365   return base::Bind(&NetLogInt64Callback, name, value);
 366 }
 367
 368 // static
 369 NetLog::ParametersCallback NetLog::StringCallback(const char* name,
 370                                                   const std::string* value) {
 371   DCHECK(value);
 372   return base::Bind(&NetLogStringCallback, name, value);
 373 }
 374
 375 // static
 376 NetLog::ParametersCallback NetLog::StringCallback(const char* name,
 377                                                   const base::string16* value) {
 378   DCHECK(value);
 379   return base::Bind(&NetLogString16Callback, name, value);
 380 }
 381
 382 void NetLog::AddEntry(EventType type,
 383                       const Source& source,
 384                       EventPhase phase,
 385                       const NetLog::ParametersCallback* parameters_callback) {
 386   LogLevel log_level = GetLogLevel();
 387   if (log_level == LOG_NONE)
 388     return;
 389   Entry entry(type, source, phase, base::TimeTicks::Now(),
 390               parameters_callback, log_level);
 391
 392   // Notify all of the log observers.
 393   base::AutoLock lock(lock_);
 394   FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntry(entry));
 395 }
 396
 397 void BoundNetLog::AddEntry(NetLog::EventType type,
 398                            NetLog::EventPhase phase) const {
 399   if (!net_log_)
 400     return;
 401   net_log_->AddEntry(type, source_, phase, NULL);
 402 }
 403
 404 void BoundNetLog::AddEntry(
 405     NetLog::EventType type,
 406     NetLog::EventPhase phase,
 407     const NetLog::ParametersCallback& get_parameters) const {
 408   if (!net_log_)
 409     return;
 410   net_log_->AddEntry(type, source_, phase, &get_parameters);
 411 }
 412
 413 void BoundNetLog::AddEvent(NetLog::EventType type) const {
 414   AddEntry(type, NetLog::PHASE_NONE);
 415 }
 416
 417 void BoundNetLog::AddEvent(
 418     NetLog::EventType type,
 419     const NetLog::ParametersCallback& get_parameters) const {
 420   AddEntry(type, NetLog::PHASE_NONE, get_parameters);
 421 }
 422
 423 void BoundNetLog::BeginEvent(NetLog::EventType type) const {
 424   AddEntry(type, NetLog::PHASE_BEGIN);
 425 }
 426
 427 void BoundNetLog::BeginEvent(
 428     NetLog::EventType type,
 429     const NetLog::ParametersCallback& get_parameters) const {
 430   AddEntry(type, NetLog::PHASE_BEGIN, get_parameters);
 431 }
 432
 433 void BoundNetLog::EndEvent(NetLog::EventType type) const {
 434   AddEntry(type, NetLog::PHASE_END);
 435 }
 436
 437 void BoundNetLog::EndEvent(
 438     NetLog::EventType type,
 439     const NetLog::ParametersCallback& get_parameters) const {
 440   AddEntry(type, NetLog::PHASE_END, get_parameters);
 441 }
 442
 443 void BoundNetLog::AddEventWithNetErrorCode(NetLog::EventType event_type,
 444                                            int net_error) const {
 445   DCHECK_NE(ERR_IO_PENDING, net_error);
 446   if (net_error >= 0) {
 447     AddEvent(event_type);
 448   } else {
 449     AddEvent(event_type, NetLog::IntegerCallback("net_error", net_error));
 450   }
 451 }
 452
 453 void BoundNetLog::EndEventWithNetErrorCode(NetLog::EventType event_type,
 454                                            int net_error) const {
 455   DCHECK_NE(ERR_IO_PENDING, net_error);
 456   if (net_error >= 0) {
 457     EndEvent(event_type);
 458   } else {
 459     EndEvent(event_type, NetLog::IntegerCallback("net_error", net_error));
 460   }
 461 }
 462
 463 void BoundNetLog::AddByteTransferEvent(NetLog::EventType event_type,
 464                                        int byte_count,
 465                                        const char* bytes) const {
 466   AddEvent(event_type, base::Bind(BytesTransferredCallback, byte_count, bytes));
 467 }
 468
 469 NetLog::LogLevel BoundNetLog::GetLogLevel() const {
 470   if (net_log_)
 471     return net_log_->GetLogLevel();
 472   return NetLog::LOG_BASIC;
 473 }
 474
 475 bool BoundNetLog::IsLoggingBytes() const {
 476   return NetLog::IsLoggingBytes(GetLogLevel());
 477 }
 478
 479 bool BoundNetLog::IsLoggingAllEvents() const {
 480   return NetLog::IsLoggingAllEvents(GetLogLevel());
 481 }
 482
 483 // static
 484 BoundNetLog BoundNetLog::Make(NetLog* net_log,
 485                               NetLog::SourceType source_type) {
 486   if (!net_log)
 487     return BoundNetLog();
 488
 489   NetLog::Source source(source_type, net_log->NextID());
 490   return BoundNetLog(source, net_log);
 491 }
 492
 493 }  // namespace net