THUAI6/CAPI/cpp/grpc/include/absl/base/internal/raw_logging.h

// Copyright 2017 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.
//
// Thread-safe logging routines that do not allocate any memory or
// acquire any locks, and can therefore be used by low-level memory
// allocation, synchronization, and signal-handling code.

#ifndef ABSL_BASE_INTERNAL_RAW_LOGGING_H_
#define ABSL_BASE_INTERNAL_RAW_LOGGING_H_

#include <string>

#include "absl/base/attributes.h"
#include "absl/base/config.h"
#include "absl/base/internal/atomic_hook.h"
#include "absl/base/log_severity.h"
#include "absl/base/macros.h"
#include "absl/base/optimization.h"
#include "absl/base/port.h"

// This is similar to LOG(severity) << format..., but
// * it is to be used ONLY by low-level modules that can't use normal LOG()
// * it is designed to be a low-level logger that does not allocate any
//   memory and does not need any locks, hence:
// * it logs straight and ONLY to STDERR w/o buffering
// * it uses an explicit printf-format and arguments list
// * it will silently chop off really long message strings
// Usage example:
//   ABSL_RAW_LOG(ERROR, "Failed foo with %i: %s", status, error);
// This will print an almost standard log line like this to stderr only:
//   E0821 211317 file.cc:123] RAW: Failed foo with 22: bad_file

#define ABSL_RAW_LOG(severity, ...)                                                                                                            \
    do                                                                                                                                         \
    {                                                                                                                                          \
        constexpr const char* absl_raw_logging_internal_basename =                                                                             \
            ::absl::raw_logging_internal::Basename(__FILE__, sizeof(__FILE__) - 1);                                                            \
        ::absl::raw_logging_internal::RawLog(ABSL_RAW_LOGGING_INTERNAL_##severity, absl_raw_logging_internal_basename, __LINE__, __VA_ARGS__); \
    } while (0)

// Similar to CHECK(condition) << message, but for low-level modules:
// we use only ABSL_RAW_LOG that does not allocate memory.
// We do not want to provide args list here to encourage this usage:
//   if (!cond)  ABSL_RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
// so that the args are not computed when not needed.
#define ABSL_RAW_CHECK(condition, message)                                   \
    do                                                                       \
    {                                                                        \
        if (ABSL_PREDICT_FALSE(!(condition)))                                \
        {                                                                    \
            ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
        }                                                                    \
    } while (0)

// ABSL_INTERNAL_LOG and ABSL_INTERNAL_CHECK work like the RAW variants above,
// except that if the richer log library is linked into the binary, we dispatch
// to that instead.  This is potentially useful for internal logging and
// assertions, where we are using RAW_LOG neither for its async-signal-safety
// nor for its non-allocating nature, but rather because raw logging has very
// few other dependencies.
//
// The API is a subset of the above: each macro only takes two arguments.  Use
// StrCat if you need to build a richer message.
#define ABSL_INTERNAL_LOG(severity, message)                                     \
    do                                                                           \
    {                                                                            \
        constexpr const char* absl_raw_logging_internal_filename = __FILE__;     \
        ::absl::raw_logging_internal::internal_log_function(                     \
            ABSL_RAW_LOGGING_INTERNAL_##severity,                                \
            absl_raw_logging_internal_filename,                                  \
            __LINE__,                                                            \
            message                                                              \
        );                                                                       \
        if (ABSL_RAW_LOGGING_INTERNAL_##severity == ::absl::LogSeverity::kFatal) \
            ABSL_INTERNAL_UNREACHABLE;                                           \
    } while (0)

#define ABSL_INTERNAL_CHECK(condition, message)                          \
    do                                                                   \
    {                                                                    \
        if (ABSL_PREDICT_FALSE(!(condition)))                            \
        {                                                                \
            std::string death_message = "Check " #condition " failed: "; \
            death_message += std::string(message);                       \
            ABSL_INTERNAL_LOG(FATAL, death_message);                     \
        }                                                                \
    } while (0)

#define ABSL_RAW_LOGGING_INTERNAL_INFO ::absl::LogSeverity::kInfo
#define ABSL_RAW_LOGGING_INTERNAL_WARNING ::absl::LogSeverity::kWarning
#define ABSL_RAW_LOGGING_INTERNAL_ERROR ::absl::LogSeverity::kError
#define ABSL_RAW_LOGGING_INTERNAL_FATAL ::absl::LogSeverity::kFatal
#define ABSL_RAW_LOGGING_INTERNAL_LEVEL(severity) \
    ::absl::NormalizeLogSeverity(severity)

namespace absl
{
    ABSL_NAMESPACE_BEGIN
    namespace raw_logging_internal
    {

        // Helper function to implement ABSL_RAW_LOG
        // Logs format... at "severity" level, reporting it
        // as called from file:line.
        // This does not allocate memory or acquire locks.
        void RawLog(absl::LogSeverity severity, const char* file, int line, const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);

        // Writes the provided buffer directly to stderr, in a signal-safe, low-level
        // manner.
        void AsyncSignalSafeWriteToStderr(const char* s, size_t len);

        // compile-time function to get the "base" filename, that is, the part of
        // a filename after the last "/" or "\" path separator.  The search starts at
        // the end of the string; the second parameter is the length of the string.
        constexpr const char* Basename(const char* fname, int offset)
        {
            return offset == 0 || fname[offset - 1] == '/' || fname[offset - 1] == '\\' ? fname + offset : Basename(fname, offset - 1);
        }

        // For testing only.
        // Returns true if raw logging is fully supported. When it is not
        // fully supported, no messages will be emitted, but a log at FATAL
        // severity will cause an abort.
        //
        // TODO(gfalcon): Come up with a better name for this method.
        bool RawLoggingFullySupported();

        // Function type for a raw_logging customization hook for suppressing messages
        // by severity, and for writing custom prefixes on non-suppressed messages.
        //
        // The installed hook is called for every raw log invocation.  The message will
        // be logged to stderr only if the hook returns true.  FATAL errors will cause
        // the process to abort, even if writing to stderr is suppressed.  The hook is
        // also provided with an output buffer, where it can write a custom log message
        // prefix.
        //
        // The raw_logging system does not allocate memory or grab locks.  User-provided
        // hooks must avoid these operations, and must not throw exceptions.
        //
        // 'severity' is the severity level of the message being written.
        // 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
        // was located.
        // 'buf' and 'buf_size' are pointers to the buffer and buffer size.  If the
        // hook writes a prefix, it must increment *buf and decrement *buf_size
        // accordingly.
        using LogFilterAndPrefixHook = bool (*)(absl::LogSeverity severity, const char* file, int line, char** buf, int* buf_size);

        // Function type for a raw_logging customization hook called to abort a process
        // when a FATAL message is logged.  If the provided AbortHook() returns, the
        // logging system will call abort().
        //
        // 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
        // was located.
        // The NUL-terminated logged message lives in the buffer between 'buf_start'
        // and 'buf_end'.  'prefix_end' points to the first non-prefix character of the
        // buffer (as written by the LogFilterAndPrefixHook.)
        //
        // The lifetime of the filename and message buffers will not end while the
        // process remains alive.
        using AbortHook = void (*)(const char* file, int line, const char* buf_start, const char* prefix_end, const char* buf_end);

        // Internal logging function for ABSL_INTERNAL_LOG to dispatch to.
        //
        // TODO(gfalcon): When string_view no longer depends on base, change this
        // interface to take its message as a string_view instead.
        using InternalLogFunction = void (*)(absl::LogSeverity severity, const char* file, int line, const std::string& message);

        ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL extern base_internal::AtomicHook<
            InternalLogFunction>
            internal_log_function;

        // Registers hooks of the above types.  Only a single hook of each type may be
        // registered.  It is an error to call these functions multiple times with
        // different input arguments.
        //
        // These functions are safe to call at any point during initialization; they do
        // not block or malloc, and are async-signal safe.
        void RegisterLogFilterAndPrefixHook(LogFilterAndPrefixHook func);
        void RegisterAbortHook(AbortHook func);
        void RegisterInternalLogFunction(InternalLogFunction func);

    }  // namespace raw_logging_internal
    ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_BASE_INTERNAL_RAW_LOGGING_H_