// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements. See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership. The ASF licenses this file

// to you 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

//

// http://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 "logging.h"

#include <bthread/bthread.h>

#include <bthread/types.h>

#include <glog/logging.h>

#include <glog/vlog_is_on.h>

#include <iomanip>

#include <iostream>

#include <mutex>

#include "config.h"

namespace doris::cloud {

static butil::LinkedList<AnnotateTag>* get_annotate_tag_list() {

static std::once_flag log_annotated_tags_key_once;

static bthread_key_t log_annotated_tags_key;

std::call_once(

log_annotated_tags_key_once,

+[](bthread_key_t* key) {

bthread_key_create(

key, +[](void* value) {

delete reinterpret_cast<butil::LinkedList<AnnotateTag>*>(value);

});

},

&log_annotated_tags_key);

auto* tag_list = reinterpret_cast<butil::LinkedList<AnnotateTag>*>(

bthread_getspecific(log_annotated_tags_key));

if (!tag_list) {

tag_list = new butil::LinkedList<AnnotateTag>();

bthread_setspecific(log_annotated_tags_key, tag_list);

}

return tag_list;

}

AnnotateTag::AnnotateTag(default_tag_t, std::string_view key, std::string value)

: key_(key), value_(std::move(value)) {

get_annotate_tag_list()->Append(this);

}

AnnotateTag::AnnotateTag(std::string_view key, std::string_view value)

: AnnotateTag(default_tag, key, fmt::format("\"{}\"", value)) {}

AnnotateTag::~AnnotateTag() {

RemoveFromList();

}

void AnnotateTag::format_tag_list(std::ostream& stream) {

butil::LinkedList<AnnotateTag>* list = get_annotate_tag_list();

butil::LinkNode<AnnotateTag>* head = list->head();

const butil::LinkNode<AnnotateTag>* end = list->end();

for (; head != end; head = head->next()) {

stream << ' ' << head->value()->key_ << '=' << head->value()->value_;

}

}

void custom_prefix(std::ostream& s, const google::LogMessageInfo& l, void*) {

// Add prefix "RuntimeLogger ".

s << "RuntimeLogger ";

// Same as in fe.log

// The following is same as default log format. eg:

// I20240605 15:25:15.677153 1763151 meta_service_txn.cpp:481] msg...

s << l.severity[0];

s << std::setw(4) << 1900 + l.time.year();

s << std::setw(2) << 1 + l.time.month();

s << std::setw(2) << l.time.day();

s << ' ';

s << std::setw(2) << l.time.hour() << ':';

s << std::setw(2) << l.time.min() << ':';

s << std::setw(2) << l.time.sec() << ".";

s << std::setw(6) << l.time.usec();

s << ' ';

s << std::setfill(' ') << std::setw(5);

s << l.thread_id << std::setfill('0');

s << ' ';

s << l.filename << ':' << l.line_number << "]";

}

// Implement the custom log format for stdout output in K8S environment

// Format: I20240605 15:25:15.677153 1763151 meta_service_txn.cpp:481] msg...

struct StdoutLogSink : google::LogSink {

void send(google::LogSeverity severity, const char* /*full_filename*/,

const char* base_filename, int line, const google::LogMessageTime& time,

const char* message, std::size_t message_len) override {

// Convert log severity to corresponding character (I/W/E/F)

char severity_char;

switch (severity) {

case google::GLOG_INFO:

severity_char = 'I';

break;

case google::GLOG_WARNING:

severity_char = 'W';

break;

case google::GLOG_ERROR:

severity_char = 'E';

break;

case google::GLOG_FATAL:

severity_char = 'F';

break;

default:

severity_char = '?';

break;

}

// Set output formatting flags

std::cout << std::setfill('0');

// 1. Log severity (I/W/E/F)

std::cout << severity_char;

// 2. Date (YYYYMMDD)

// Note: tm_year is years since 1900, tm_mon is 0-based (0-11)

std::cout << std::setw(4) << (time.year() + 1900) << std::setw(2) << std::setfill('0')

<< (time.month() + 1) << std::setw(2) << std::setfill('0') << time.day();

// 3. Time (HH:MM:SS.ffffff)

std::cout << " " << std::setw(2) << std::setfill('0') << time.hour() << ":" << std::setw(2)

<< std::setfill('0') << time.min() << ":" << std::setw(2) << std::setfill('0')

<< time.sec() << "." << std::setw(6) << std::setfill('0') << time.usec();

// 4. Thread ID

std::cout << " " << std::setfill(' ') << std::setw(5) << getpid() << std::setfill('0');

// 5. Filename and line number

std::cout << " " << base_filename << ":" << line << "] ";

// 6. Log message

std::cout.write(message, message_len);

// Add newline and flush

std::cout << std::endl;

}

};

static StdoutLogSink stdout_log_sink;

/**

* @param basename the basename of log file

* @return true for success

*/

bool init_glog(const char* basename) {

static std::mutex mtx;

static bool inited = false;

std::lock_guard<std::mutex> logging_lock(mtx);

if (inited) return true;

bool log_to_console = (getenv("DORIS_LOG_TO_STDERR") != nullptr);

if (log_to_console) {

if (config::enable_file_logger) {

// will output log to log file and output log to stdout

google::AddLogSink(&stdout_log_sink);

} else {

// enable_file_logger is false, will only output log to stdout

// Not output to stderr because doris_cloud.out will output log to stderr

FLAGS_logtostdout = true;

}

} else {

FLAGS_alsologtostderr = false;

}

// Don't log to stderr except fatal level

// so fatal log can output to doris_cloud.out .

FLAGS_stderrthreshold = google::FATAL;

// Set glog log dir

FLAGS_log_dir = config::log_dir;

// Buffer log messages for at most this many seconds

FLAGS_logbufsecs = 1;

// Set log roll mode

// Candidates: day, hour, size

FLAGS_log_split_method = "size";

// Sets the maximum log file size (in MB).

FLAGS_max_log_size = config::log_size_mb;

// Set roll num

FLAGS_log_filenum_quota = config::log_filenum_quota;

#ifdef GLOG_HAS_WARN_LOG_FILENUM_QUOTA

// Set warn log roll num

FLAGS_warn_log_filenum_quota = config::warn_log_filenum_quota;

#endif

// clang-format off

// set log level

std::string& loglevel = config::log_level;

// Can be 0 1 2 3 ... the larger the higher level for logging,

// corrensponding to INFO WARNING ERROR FATAL

// const int GLOG_INFO = 0, GLOG_WARNING = 1, GLOG_ERROR = 2, GLOG_FATAL = 3, NUM_SEVERITIES = 4;

auto tolower = [](std::string s) { for (auto& i : s) i |= 0x20; return s; };

FLAGS_minloglevel = tolower(loglevel) == "info" ? 0

: tolower(loglevel) == "warn" ? 1

: tolower(loglevel) == "error" ? 2

: tolower(loglevel) == "fatal" ? 3

: 0; // Default INFO

// clang-format on

// Log messages at a level <= this flag are buffered.

// Log messages at a higher level are flushed immediately.

FLAGS_logbuflevel = config::log_immediate_flush ? -1 : 0;

// Set verbose modules

FLAGS_v = -1;

for (auto& i : config::log_verbose_modules) {

if (i.empty()) continue;

google::SetVLOGLevel(i.c_str(), config::log_verbose_level);

}

if (log_to_console) {

// Only add prefix if log output to stderr

google::InitGoogleLogging(basename, &custom_prefix);

} else {

google::InitGoogleLogging(basename);

}

inited = true;

return true;

}

} // namespace doris::cloud