Abseil LogSink 분석

1
#include "absl/log/log_sink.h"
2
#include "absl/log/log_sink_registry.h"
3

4
class MySink : public absl::LogSink {
5
public:
6
    void Send(const absl::LogEntry& entry) override {
7
        // 한 줄 로그가 들어올 때마다 호출
8
        std::cerr << "[CUSTOM] " << entry.text_message() << "\n";
9
    }
10
};
11

12
MySink my_sink;
13
absl::AddLogSink(&my_sink);
14
// ... LOG 호출들 ...
15
absl::RemoveLogSink(&my_sink);

1
class LogSink {
2
public:
3
    virtual ~LogSink() = default;
4

5
    // 주된 메서드 — 매 로그 entry마다 호출
6
    virtual void Send(const absl::LogEntry& entry) = 0;
7

8
    // 선택적 — Send 후 flush 보장 필요 시
9
    virtual void Flush() {}
10
};

1
class AsyncSink : public absl::LogSink {
2
public:
3
    void Send(const absl::LogEntry& entry) override {
4
        // 1. 동기적으로 가벼운 직렬화
5
        Record r{
6
            .severity = entry.log_severity(),
7
            .timestamp = entry.timestamp(),
8
            .message = std::string(entry.text_message()),
9
        };
10
        // 2. 락 한 번 + queue push
11
        absl::MutexLock lock(&mu_);
12
        queue_.push_back(std::move(r));
13
        cv_.SignalAll();
14
    }
15

16
    void Flush() override {
17
        absl::MutexLock lock(&mu_);
18
        while (!queue_.empty()) cv_.Wait(&mu_);
19
    }
20

21
private:
22
    void Worker() {
23
        // 별도 스레드에서 큐를 비우고 네트워크로 전송
24
    }
25

26
    absl::Mutex mu_;
27
    std::deque<Record> queue_ ABSL_GUARDED_BY(mu_);
28
    absl::CondVar cv_;
29
};

1
absl::AddLogSink(&my_sink);     // 등록
2
absl::RemoveLogSink(&my_sink);  // 해제

1
absl::RemoveLogSink(&my_sink);
2
my_sink.Flush();   // 진행 중 Send 완료 보장
3
absl::FlushLogSinks();   // 전역 flush
4
// 이제 my_sink 파괴 가능

1
#include "absl/log/scoped_mock_log.h"
2

3
TEST(MyTest, LogsWarning) {
4
    absl::ScopedMockLog log;
5
    EXPECT_CALL(log, Log(absl::LogSeverity::kWarning, ::testing::_,
6
                         ::testing::HasSubstr("slow")));
7
    log.StartCapturingLogs();
8

9
    DoSlowOperation();   // LOG(WARNING) << "slow ..." 발생 예상
10
}

1
class FileSink : public absl::LogSink {
2
public:
3
    explicit FileSink(absl::string_view path) : f_(std::fopen(std::string(path).c_str(), "a")) {}
4
    ~FileSink() { if (f_) std::fclose(f_); }
5

6
    void Send(const absl::LogEntry& entry) override {
7
        absl::MutexLock lock(&mu_);
8
        if (!f_) return;
9
        std::string formatted = absl::StrCat(
10
            entry.text_message_with_prefix(), "\n");
11
        std::fwrite(formatted.data(), 1, formatted.size(), f_);
12
    }
13

14
    void Flush() override {
15
        absl::MutexLock lock(&mu_);
16
        if (f_) std::fflush(f_);
17
    }
18

19
private:
20
    absl::Mutex mu_;
21
    std::FILE* f_ ABSL_GUARDED_BY(mu_);
22
};

1
StderrSink stderr_sink;       // 콘솔
2
FileSink file_sink("/var/log/svc.log");
3
AsyncSink remote_sink(...);   // Loki, Splunk 등
4

5
absl::AddLogSink(&stderr_sink);
6
absl::AddLogSink(&file_sink);
7
absl::AddLogSink(&remote_sink);

1
void Send(const absl::LogEntry& entry) override {
2
    if (entry.log_severity() < absl::LogSeverity::kWarning) return;
3
    // ...
4
}

1
// 회피 — Send 안에서 비싼 IO
2
void Send(const absl::LogEntry& entry) override {
3
    HttpPost("/log", absl::StrCat(...));   // ❌ LOG 호출자가 네트워크 대기
4
}
5

6
// Good — 큐 + worker

1
// 회피 — sink 안에서 다시 LOG 호출
2
void Send(const absl::LogEntry& entry) override {
3
    LOG(ERROR) << "sink error: " << ...;   // ❌ 재진입 — 데드락 가능
4
}
5

6
// Good — std::cerr 또는 raw_logging
7
ABSL_RAW_LOG(ERROR, "sink error: %s", ...);

1
// 회피 — sink lifetime 관리 부주의
2
{
3
    MySink s;
4
    absl::AddLogSink(&s);
5
}   // ❌ s 소멸 후에도 등록 상태
6
// → 다음 LOG에서 댕글링