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