146 lines
4.8 KiB
C++
146 lines
4.8 KiB
C++
// Copyright 2022 The Abseil Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "absl/log/internal/globals.h"
|
|
|
|
#include <atomic>
|
|
#include <cstdio>
|
|
|
|
#if defined(__EMSCRIPTEN__)
|
|
#include <emscripten/console.h>
|
|
#endif
|
|
|
|
#include "absl/base/attributes.h"
|
|
#include "absl/base/config.h"
|
|
#include "absl/base/internal/raw_logging.h"
|
|
#include "absl/base/log_severity.h"
|
|
#include "absl/strings/string_view.h"
|
|
#include "absl/strings/strip.h"
|
|
#include "absl/time/time.h"
|
|
|
|
namespace absl {
|
|
ABSL_NAMESPACE_BEGIN
|
|
namespace log_internal {
|
|
|
|
namespace {
|
|
// Keeps track of whether Logging initialization is finalized.
|
|
// Log messages generated before that will go to stderr.
|
|
ABSL_CONST_INIT std::atomic<bool> logging_initialized(false);
|
|
|
|
// The TimeZone used for logging. This may only be set once.
|
|
ABSL_CONST_INIT std::atomic<absl::TimeZone*> timezone_ptr{nullptr};
|
|
|
|
// If true, the logging library will symbolize stack in fatal messages
|
|
ABSL_CONST_INIT std::atomic<bool> symbolize_stack_trace(true);
|
|
|
|
// Specifies maximum number of stack frames to report in fatal messages.
|
|
ABSL_CONST_INIT std::atomic<int> max_frames_in_stack_trace(64);
|
|
|
|
ABSL_CONST_INIT std::atomic<bool> exit_on_dfatal(true);
|
|
ABSL_CONST_INIT std::atomic<bool> suppress_sigabort_trace(false);
|
|
} // namespace
|
|
|
|
bool IsInitialized() {
|
|
return logging_initialized.load(std::memory_order_acquire);
|
|
}
|
|
|
|
void SetInitialized() {
|
|
logging_initialized.store(true, std::memory_order_release);
|
|
}
|
|
|
|
void WriteToStderr(absl::string_view message, absl::LogSeverity severity) {
|
|
if (message.empty()) return;
|
|
#if defined(__EMSCRIPTEN__)
|
|
// In WebAssembly, bypass filesystem emulation via fwrite.
|
|
// Skip a trailing newline character as emscripten_errn adds one itself.
|
|
const auto message_minus_newline = absl::StripSuffix(message, "\n");
|
|
// emscripten_errn was introduced in 3.1.41 but broken in standalone mode
|
|
// until 3.1.43.
|
|
#if ABSL_INTERNAL_EMSCRIPTEN_VERSION >= 3001043
|
|
emscripten_errn(message_minus_newline.data(), message_minus_newline.size());
|
|
#else
|
|
std::string null_terminated_message(message_minus_newline);
|
|
_emscripten_err(null_terminated_message.c_str());
|
|
#endif
|
|
#else
|
|
// Avoid using std::cerr from this module since we may get called during
|
|
// exit code, and cerr may be partially or fully destroyed by then.
|
|
std::fwrite(message.data(), message.size(), 1, stderr);
|
|
#endif
|
|
|
|
#if defined(_WIN64) || defined(_WIN32) || defined(_WIN16)
|
|
// C99 requires stderr to not be fully-buffered by default (7.19.3.7), but
|
|
// MS CRT buffers it anyway, so we must `fflush` to ensure the string hits
|
|
// the console/file before the program dies (and takes the libc buffers
|
|
// with it).
|
|
// https://docs.microsoft.com/en-us/cpp/c-runtime-library/stream-i-o
|
|
if (severity >= absl::LogSeverity::kWarning) {
|
|
std::fflush(stderr);
|
|
}
|
|
#else
|
|
// Avoid unused parameter warning in this branch.
|
|
(void)severity;
|
|
#endif
|
|
}
|
|
|
|
void SetTimeZone(absl::TimeZone tz) {
|
|
absl::TimeZone* expected = nullptr;
|
|
absl::TimeZone* new_tz = new absl::TimeZone(tz);
|
|
// timezone_ptr can only be set once, otherwise new_tz is leaked.
|
|
if (!timezone_ptr.compare_exchange_strong(expected, new_tz,
|
|
std::memory_order_release,
|
|
std::memory_order_relaxed)) {
|
|
ABSL_RAW_LOG(FATAL,
|
|
"absl::log_internal::SetTimeZone() has already been called");
|
|
}
|
|
}
|
|
|
|
const absl::TimeZone* TimeZone() {
|
|
return timezone_ptr.load(std::memory_order_acquire);
|
|
}
|
|
|
|
bool ShouldSymbolizeLogStackTrace() {
|
|
return symbolize_stack_trace.load(std::memory_order_acquire);
|
|
}
|
|
|
|
void EnableSymbolizeLogStackTrace(bool on_off) {
|
|
symbolize_stack_trace.store(on_off, std::memory_order_release);
|
|
}
|
|
|
|
int MaxFramesInLogStackTrace() {
|
|
return max_frames_in_stack_trace.load(std::memory_order_acquire);
|
|
}
|
|
|
|
void SetMaxFramesInLogStackTrace(int max_num_frames) {
|
|
max_frames_in_stack_trace.store(max_num_frames, std::memory_order_release);
|
|
}
|
|
|
|
bool ExitOnDFatal() { return exit_on_dfatal.load(std::memory_order_acquire); }
|
|
|
|
void SetExitOnDFatal(bool on_off) {
|
|
exit_on_dfatal.store(on_off, std::memory_order_release);
|
|
}
|
|
|
|
bool SuppressSigabortTrace() {
|
|
return suppress_sigabort_trace.load(std::memory_order_acquire);
|
|
}
|
|
|
|
bool SetSuppressSigabortTrace(bool on_off) {
|
|
return suppress_sigabort_trace.exchange(on_off);
|
|
}
|
|
|
|
} // namespace log_internal
|
|
ABSL_NAMESPACE_END
|
|
} // namespace absl
|