logging_win.cc revision 21d179b334e59e9a3bfcaed4c4430bef1bc5759d 
1// Copyright (c) 2009 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 "base/logging_win.h"
6#include "base/singleton.h"
7#include <initguid.h>  // NOLINT
8
9namespace logging {
10
11using base::win::EtwEventLevel;
12using base::win::EtwMofEvent;
13
14DEFINE_GUID(kLogEventId,
15    0x7fe69228, 0x633e, 0x4f06, 0x80, 0xc1, 0x52, 0x7f, 0xea, 0x23, 0xe3, 0xa7);
16
17LogEventProvider::LogEventProvider() : old_log_level_(LOG_NONE) {
18}
19
20LogEventProvider* LogEventProvider::GetInstance() {
21  return Singleton<LogEventProvider,
22                   StaticMemorySingletonTraits<LogEventProvider> >::get();
23}
24
25bool LogEventProvider::LogMessage(logging::LogSeverity severity,
26    const char* file, int line, size_t message_start,
27    const std::string& message) {
28  EtwEventLevel level = TRACE_LEVEL_NONE;
29
30  // Convert the log severity to the most appropriate ETW trace level.
31  if (severity >= 0) {
32    switch (severity) {
33      case LOG_INFO:
34        level = TRACE_LEVEL_INFORMATION;
35        break;
36      case LOG_WARNING:
37        level = TRACE_LEVEL_WARNING;
38        break;
39      case LOG_ERROR:
40      case LOG_ERROR_REPORT:
41        level = TRACE_LEVEL_ERROR;
42        break;
43      case LOG_FATAL:
44        level = TRACE_LEVEL_FATAL;
45        break;
46    }
47  } else {  // severity < 0 is VLOG verbosity levels.
48    level = TRACE_LEVEL_INFORMATION - severity;
49  }
50
51  // Bail if we're not logging, not at that level,
52  // or if we're post-atexit handling.
53  LogEventProvider* provider = LogEventProvider::GetInstance();
54  if (provider == NULL || level > provider->enable_level())
55    return false;
56
57  // And now log the event.
58  if (provider->enable_flags() & ENABLE_LOG_MESSAGE_ONLY) {
59    EtwMofEvent<1> event(kLogEventId, LOG_MESSAGE, level);
60    event.SetField(0, message.length() + 1 - message_start,
61        message.c_str() + message_start);
62
63    provider->Log(event.get());
64  } else {
65    const size_t kMaxBacktraceDepth = 32;
66    void* backtrace[kMaxBacktraceDepth];
67    DWORD depth = 0;
68
69    // Capture a stack trace if one is requested.
70    // requested per our enable flags.
71    if (provider->enable_flags() & ENABLE_STACK_TRACE_CAPTURE)
72      depth = CaptureStackBackTrace(2, kMaxBacktraceDepth, backtrace, NULL);
73
74    EtwMofEvent<5> event(kLogEventId, LOG_MESSAGE_FULL, level);
75    if (file == NULL)
76      file = "";
77
78    // Add the stack trace.
79    event.SetField(0, sizeof(depth), &depth);
80    event.SetField(1, sizeof(backtrace[0]) * depth, &backtrace);
81    // The line.
82    event.SetField(2, sizeof(line), &line);
83    // The file.
84    event.SetField(3, strlen(file) + 1, file);
85    // And finally the message.
86    event.SetField(4, message.length() + 1 - message_start,
87        message.c_str() + message_start);
88
89    provider->Log(event.get());
90  }
91
92  // Don't increase verbosity in other log destinations.
93  if (severity < provider->old_log_level_)
94    return true;
95
96  return false;
97}
98
99void LogEventProvider::Initialize(const GUID& provider_name) {
100  LogEventProvider* provider = LogEventProvider::GetInstance();
101
102  provider->set_provider_name(provider_name);
103  provider->Register();
104
105  // Register our message handler with logging.
106  SetLogMessageHandler(LogMessage);
107}
108
109void LogEventProvider::Uninitialize() {
110  LogEventProvider::GetInstance()->Unregister();
111}
112
113void LogEventProvider::OnEventsEnabled() {
114  // Grab the old log level so we can restore it later.
115  old_log_level_ = GetMinLogLevel();
116
117  // Convert the new trace level to a logging severity
118  // and enable logging at that level.
119  EtwEventLevel level = enable_level();
120  if (level == TRACE_LEVEL_NONE || level == TRACE_LEVEL_FATAL) {
121    SetMinLogLevel(LOG_FATAL);
122  } else if (level == TRACE_LEVEL_ERROR) {
123    SetMinLogLevel(LOG_ERROR);
124  } else if (level == TRACE_LEVEL_WARNING) {
125    SetMinLogLevel(LOG_WARNING);
126  } else if (level == TRACE_LEVEL_INFORMATION) {
127    SetMinLogLevel(LOG_INFO);
128  } else if (level >= TRACE_LEVEL_VERBOSE) {
129    // Above INFO, we enable verbose levels with negative severities.
130    SetMinLogLevel(TRACE_LEVEL_INFORMATION - level);
131  }
132}
133
134void LogEventProvider::OnEventsDisabled() {
135  // Restore the old log level.
136  SetMinLogLevel(old_log_level_);
137}
138
139}  // namespace logging
140