Abseil raw_logging — heap-free 로깅

1
#include "absl/base/internal/raw_logging.h"
2

3
ABSL_RAW_LOG(INFO, "message");
4
ABSL_RAW_LOG(ERROR, "failed: %d", error_code);
5
ABSL_RAW_LOG(FATAL, "fatal: %s", msg);
6

7
ABSL_RAW_CHECK(condition, "assertion message");

1
// 의사 코드
2
namespace absl::raw_log_internal {
3

4
void RawLog(LogSeverity severity, const char* file, int line,
5
            const char* format, ...);
6

7
void RawLogDoLog(LogSeverity severity, const char* file, int line,
8
                 const char* format, va_list args) {
9
    char buffer[kLogBufSize];  // stack에 fixed-size buffer
10
    int n = vsnprintf(buffer, kLogBufSize, format, args);
11

12
    // 단순 write() syscall — heap, exception, mutex 없음
13
    write(STDERR_FILENO, buffer, std::min(n, kLogBufSize - 1));
14
    write(STDERR_FILENO, "\n", 1);
15

16
    if (severity == LogSeverity::kFatal) {
17
        std::abort();
18
    }
19
}
20

21
}  // namespace absl::raw_log_internal

1
void SegvHandler(int sig) {
2
    // signal handler는 async-signal-safe 함수만 호출 가능
3
    // 일반 LOG는 mutex 잡으므로 unsafe
4
    ABSL_RAW_LOG(ERROR, "SIGSEGV at pid %d", getpid());
5
    abort();
6
}
7

8
signal(SIGSEGV, SegvHandler);

1
void* AllocateOrDie(size_t n) {
2
    void* p = malloc(n);
3
    if (ABSL_PREDICT_FALSE(!p)) {
4
        // 일반 LOG가 heap을 더 쓸 수 있다. RAW_LOG가 안전.
5
        ABSL_RAW_LOG(FATAL, "OOM: failed to allocate %zu bytes", n);
6
    }
7
    return p;
8
}

1
namespace {
2
// global static 객체의 ctor
3
struct InitOnStartup {
4
    InitOnStartup() {
5
        // 다른 static 객체의 초기화 순서 보장 안 됨
6
        // 일반 LOG는 자기 초기화에 의존하므로 깨질 수 있음
7
        ABSL_RAW_LOG(INFO, "Module X initializing");
8
    }
9
} init_x;
10
}

1
ABSL_RAW_CHECK(ptr != nullptr, "ptr must not be null");
2
// 조건이 false면 RAW_LOG(FATAL) + abort()

1
// 회피 — signal handler에서 일반 LOG
2
void Handler(int sig) {
3
    LOG(ERROR) << "got signal " << sig;  // unsafe
4
    abort();
5
}
6

7
// Good
8
void Handler(int sig) {
9
    ABSL_RAW_LOG(ERROR, "got signal %d", sig);
10
    abort();
11
}

1
// 회피 — RAW_LOG를 일상적으로 사용
2
void Process() {
3
    ABSL_RAW_LOG(INFO, "processing");  // sink, formatting 등 못 씀
4
}
5

6
// Good — 일반 코드는 일반 LOG
7
void Process() {
8
    LOG(INFO) << "processing";
9
}

1
// 회피 — RAW_LOG에 stream syntax
2
ABSL_RAW_LOG(INFO, "value: " << x);  // 컴파일 에러
3
// RAW_LOG는 printf-style.
4

5
// Good
6
ABSL_RAW_LOG(INFO, "value: %d", x);

1
// 회피 — RAW_LOG에 std::string
2
std::string msg = absl::StrCat("value: ", x);
3
ABSL_RAW_LOG(INFO, "%s", msg.c_str());
4
// std::string 자체가 heap을 쓸 수 있다. RAW의 의도와 모순.
5

6
// Good — char buffer
7
char buf[64];
8
snprintf(buf, sizeof(buf), "value: %d", x);
9
ABSL_RAW_LOG(INFO, "%s", buf);
10
// 또는 format string에 직접
11
ABSL_RAW_LOG(INFO, "value: %d", x);

1
// 회피 — RAW_LOG를 hot path에
2
for (int i = 0; i < 1000000; ++i) {
3
    ABSL_RAW_LOG(INFO, "iter %d", i);  // syscall * 1M회
4
}
5
// stderr buffered I/O이 아니므로 매우 느림.
6

7
// Good — 일반 LOG이거나 logging 자체를 제거

1
// 회피 — large message
2
char buf[10000];
3
snprintf(buf, sizeof(buf), "...");
4
ABSL_RAW_LOG(INFO, "%s", buf);
5
// RAW_LOG의 내부 buffer는 보통 1KB. 잘림.
6

7
// Good — 짧은 핵심만 RAW_LOG
8
ABSL_RAW_LOG(ERROR, "OOM at module %s", module_name);