New API for managing TDLib logs.

GitOrigin-RevId: 60f520027bf16f53b927c72d0151884fda64ebbc

Author: levlam

CMakeLists.txt

@@ -377,6 +377,7 @@ set(TDLIB_SOURCE
   td/telegram/InputMessageText.cpp
   td/telegram/LanguagePackManager.cpp
   td/telegram/Location.cpp
+  td/telegram/Logging.cpp
   td/telegram/MessageContent.cpp
   td/telegram/MessageEntity.cpp
   td/telegram/MessagesDb.cpp
@@ -500,6 +501,7 @@ set(TDLIB_SOURCE
   td/telegram/logevent/LogEvent.h
   td/telegram/logevent/LogEventHelper.h
   td/telegram/logevent/SecretChatEvent.h
+  td/telegram/Logging.h
   td/telegram/MessageContent.h
   td/telegram/MessageEntity.h
   td/telegram/MessageId.h

SplitSource.php

@@ -147,7 +147,6 @@ function split_file($file, $chunks, $undo) {
                            '(CREATE_REQUEST|CREATE_NO_ARGS_REQUEST)[(](?<name>[A-Z][A-Za-z]*)|'.
                            '(?<name>complete_pending_preauthentication_requests)|'.
                            '(Up|Down)load[a-zA-Z]*C(?<name>allback)|(up|down)load_[a-z_]*_c(?<name>allback)_|'.
-                           '(?<name>V)(LOG.td_init|ERBOSITY_NAME)|'.
                            '(?<name>LogEvent)[^sA]|'.
                            '(?<name>parse)[(]|'.
                            '(?<name>store)[(]/', $f, $matches, PREG_SET_ORDER)) {

td/generate/DotnetTlDocumentationGenerator.php

@@ -8,7 +8,7 @@ protected function escapeDocumentation($doc)
     {
         $doc = htmlspecialchars($doc, ENT_XML1);
         $doc = str_replace('*/', '*/', $doc);
-        $doc = preg_replace_callback('/_([A-Za-z])/', function ($matches) {return strtoupper($matches[1]);}, $doc);
+        $doc = preg_replace_callback('/(?<!")_([A-Za-z])/', function ($matches) {return strtoupper($matches[1]);}, $doc);
         return $doc;
     }
 

td/generate/JavadocTlDocumentationGenerator.php

@@ -12,7 +12,7 @@ protected function escapeDocumentation($doc)
     {
         $doc = htmlspecialchars($doc);
         $doc = str_replace('*/', '*/', $doc);
-        $doc = preg_replace_callback('/_([A-Za-z])/', function ($matches) {return strtoupper($matches[1]);}, $doc);
+        $doc = preg_replace_callback('/(?<!")_([A-Za-z])/', function ($matches) {return strtoupper($matches[1]);}, $doc);
         return $doc;
     }
 

td/generate/scheme/td_api.tl

@@ -2317,6 +2317,25 @@ updateNewCustomQuery id:int64 data:string timeout:int32 = Update;
 updates updates:vector<Update> = Updates;
 
 
+//@class LogStream @description Describes a stream to which TDLib internal log is written
+
+//@description The log is written to stderr or an OS specific log
+logStreamDefault = LogStream;
+
+//@description TDLib needs TdlibParameters for initialization @path Path to the file to where the internal TDLib log will be written @max_file_size Maximum size of the file to where the internal TDLib log is written before the file will be auto-rotated
+logStreamFile path:string max_file_size:int53 = LogStream;
+
+//@description The log is written nowhere
+logStreamEmpty = LogStream;
+
+
+//@description Contains a TDLib internal log verbosity level @verbosity_level Log verbosity level
+logVerbosityLevel verbosity_level:int32 = LogVerbosityLevel;
+
+//@description Contains a list of available TDLib internal log tags @tags List of log tags
+logTags tags:vector<string> = LogTags;
+
+
 //@description A simple object containing a number; for testing only @value Number
 testInt value:int32 = TestInt;
 //@description A simple object containing a string; for testing only @value String
@@ -3378,6 +3397,30 @@ getProxyLink proxy_id:int32 = Text;
 pingProxy proxy_id:int32 = Seconds;
 
 
+//@description Sets new log stream for internal logging of TDLib. This is an offline method. Can be called before authorization. Can be called synchronously @log_stream New log stream
+setLogStream log_stream:LogStream = Ok;
+
+//@description Returns information about currently used log stream for internal logging of TDLib. This is an offline method. Can be called before authorization. Can be called synchronously
+getLogStream = LogStream;
+
+//@description Sets the verbosity level of the internal logging of TDLib. This is an offline method. Can be called before authorization. Can be called synchronously
+//@new_verbosity_level New value of the verbosity level for logging. Value 0 corresponds to fatal errors, value 1 corresponds to errors, value 2 corresponds to warnings and debug warnings, value 3 corresponds to informational, value 4 corresponds to debug, value 5 corresponds to verbose debug, value greater than 5 and up to 1023 can be used to enable even more logging
+setLogVerbosityLevel new_verbosity_level:int32 = Ok;
+
+//@description Returns current verbosity level of the internal logging of TDLib. This is an offline method. Can be called before authorization. Can be called synchronously
+getLogVerbosityLevel = LogVerbosityLevel;
+
+//@description Returns list of available TDLib internal log tags. Currently returns ["td_init", "update_file", "connections", "binlog", "proxy", "net_query", "td_requests", "dc", "files", "mtproto", "raw_mtproto", "fd", "actor", "buffer", "sqlite"]
+getLogTags = LogTags;
+
+//@description Sets the verbosity level for a specified TDLib internal log tag. This is an offline method. Can be called before authorization. Can be called synchronously
+//@tag Logging tag to change verbosity level @new_verbosity_level New verbosity level; 1-1024
+setLogTagVerbosityLevel tag:string new_verbosity_level:int32 = Ok;
+
+//@description Returns current verbosity level for a specified TDLib internal log tag. This is an offline method. Can be called before authorization. Can be called synchronously @tag Logging tag to change verbosity level
+getLogTagVerbosityLevel tag:string = LogVerbosityLevel;
+
+
 //@description Does nothing; for testing only
 testCallEmpty = Ok;
 //@description Returns the received string; for testing only @x String to return
@@ -3402,7 +3445,3 @@ testGetDifference = Ok;
 testUseUpdate = Update;
 //@description Does nothing and ensures that the Error object is used; for testing only
 testUseError = Error;
-//@description Changes verbosity level for a specified log tag; for testing only. This is an offline method. Can be called before authorization. Can be called synchronously
-//@tag Logging tag to change verbosity level (one of "td_init", "update_file", "connections", "binlog", "proxy", "net_query", "td_requests", "dc", "files", "mtproto", "raw_mtproto", "fd", "actor", "buffer", "sqlite")
-//@new_verbosity_level New verbosity level; 1-1024
-testSetLogTagVerbosityLevel tag:string new_verbosity_level:int32 = Ok;

td/generate/scheme/td_api.tlo

@@ -6,8 +6,9 @@
 //
 #include "td/telegram/Log.h"
 
+#include "td/telegram/Logging.h"
+
 #include "td/utils/common.h"
-#include "td/utils/FileLog.h"
 #include "td/utils/logging.h"
 #include "td/utils/Slice.h"
 
@@ -16,8 +17,7 @@
 namespace td {
 
 static std::mutex log_mutex;
-static FileLog file_log;
-static TsLog ts_log(&file_log);
+static string log_file_path;
 static int64 max_log_file_size = 10 << 20;
 static Log::FatalErrorCallbackPtr fatal_error_callback;
 
@@ -29,12 +29,12 @@ static void fatal_error_callback_wrapper(CSlice message) {
 bool Log::set_file_path(string file_path) {
   std::lock_guard<std::mutex> lock(log_mutex);
   if (file_path.empty()) {
-    log_interface = default_log_interface;
-    return true;
+    log_file_path.clear();
+    return Logging::set_current_stream(td_api::make_object<td_api::logStreamDefault>()).is_ok();
   }
 
-  if (file_log.init(file_path, max_log_file_size)) {
-    log_interface = &ts_log;
+  if (Logging::set_current_stream(td_api::make_object<td_api::logStreamFile>(file_path, max_log_file_size)).is_ok()) {
+    log_file_path = std::move(file_path);
     return true;
   }
 
@@ -43,15 +43,13 @@ bool Log::set_file_path(string file_path) {
 
 void Log::set_max_file_size(int64 max_file_size) {
   std::lock_guard<std::mutex> lock(log_mutex);
-  max_log_file_size = max(max_file_size, static_cast<int64>(0));
-  file_log.set_rotate_threshold(max_log_file_size);
+  max_log_file_size = max(max_file_size, static_cast<int64>(1));
+  Logging::set_current_stream(td_api::make_object<td_api::logStreamFile>(log_file_path, max_log_file_size)).ignore();
 }
 
 void Log::set_verbosity_level(int new_verbosity_level) {
   std::lock_guard<std::mutex> lock(log_mutex);
-  if (0 <= new_verbosity_level && new_verbosity_level <= 1024) {
-    SET_VERBOSITY_LEVEL(VERBOSITY_NAME(FATAL) + new_verbosity_level);
-  }
+  Logging::set_verbosity_level(new_verbosity_level).ignore();
 }
 
 void Log::set_fatal_error_callback(FatalErrorCallbackPtr callback) {

td/telegram/Log.cpp

@@ -39,6 +39,7 @@
 #include "td/telegram/HashtagHints.h"
 #include "td/telegram/InlineQueriesManager.h"
 #include "td/telegram/LanguagePackManager.h"
+#include "td/telegram/Logging.h"
 #include "td/telegram/MessageEntity.h"
 #include "td/telegram/MessageId.h"
 #include "td/telegram/MessagesManager.h"
@@ -76,8 +77,6 @@
 
 #include "td/mtproto/utils.h"  // for create_storer, fetch_result, etc, TODO
 
-#include "tdnet/td/net/TransparentProxy.h"
-
 #include "td/utils/buffer.h"
 #include "td/utils/filesystem.h"
 #include "td/utils/format.h"
@@ -3116,7 +3115,13 @@ bool Td::is_synchronous_request(int32 id) {
     case td_api::getFileExtension::ID:
     case td_api::cleanFileName::ID:
     case td_api::getLanguagePackString::ID:
-    case td_api::testSetLogTagVerbosityLevel::ID:
+    case td_api::setLogStream::ID:
+    case td_api::getLogStream::ID:
+    case td_api::setLogVerbosityLevel::ID:
+    case td_api::getLogVerbosityLevel::ID:
+    case td_api::getLogTags::ID:
+    case td_api::setLogTagVerbosityLevel::ID:
+    case td_api::getLogTagVerbosityLevel::ID:
       return true;
     default:
       return false;
@@ -6715,6 +6720,34 @@ void Td::on_request(uint64 id, const td_api::getLanguagePackString &request) {
   UNREACHABLE();
 }
 
+void Td::on_request(uint64 id, const td_api::setLogStream &request) {
+  UNREACHABLE();
+}
+
+void Td::on_request(uint64 id, const td_api::getLogStream &request) {
+  UNREACHABLE();
+}
+
+void Td::on_request(uint64 id, const td_api::setLogVerbosityLevel &request) {
+  UNREACHABLE();
+}
+
+void Td::on_request(uint64 id, const td_api::getLogVerbosityLevel &request) {
+  UNREACHABLE();
+}
+
+void Td::on_request(uint64 id, const td_api::getLogTags &request) {
+  UNREACHABLE();
+}
+
+void Td::on_request(uint64 id, const td_api::setLogTagVerbosityLevel &request) {
+  UNREACHABLE();
+}
+
+void Td::on_request(uint64 id, const td_api::getLogTagVerbosityLevel &request) {
+  UNREACHABLE();
+}
+
 td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::getTextEntities &request) {
   if (!check_utf8(request.text_)) {
     return make_error(400, "Text must be encoded in UTF-8");
@@ -6769,77 +6802,67 @@ td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::getLangua
       request.language_pack_database_path_, request.localization_target_, request.language_pack_id_, request.key_);
 }
 
-// test
-void Td::on_request(uint64 id, td_api::testNetwork &request) {
-  create_handler<TestQuery>(id)->send();
+td_api::object_ptr<td_api::Object> Td::do_static_request(td_api::setLogStream &request) {
+  auto result = Logging::set_current_stream(std::move(request.log_stream_));
+  if (result.is_ok()) {
+    return td_api::make_object<td_api::ok>();
+  } else {
+    return make_error(400, result.message());
+  }
 }
 
-void Td::on_request(uint64 id, td_api::testGetDifference &request) {
-  updates_manager_->get_difference("testGetDifference");
-  send_closure(actor_id(this), &Td::send_result, id, make_tl_object<td_api::ok>());
+td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::getLogStream &request) {
+  auto result = Logging::get_current_stream();
+  if (result.is_ok()) {
+    return result.move_as_ok();
+  } else {
+    return make_error(400, result.error().message());
+  }
 }
 
-int *Td::get_log_verbosity_level(Slice name) {
-  if (name == "td_init") {
-    return &VERBOSITY_NAME(td_init);
-  }
-  if (name == "update_file") {
-    return &VERBOSITY_NAME(update_file);
-  }
-  if (name == "connections") {
-    return &VERBOSITY_NAME(connections);
-  }
-  if (name == "binlog") {
-    return &VERBOSITY_NAME(binlog);
-  }
-  if (name == "proxy") {
-    return &VERBOSITY_NAME(proxy);
-  }
-  if (name == "net_query") {
-    return &VERBOSITY_NAME(net_query);
-  }
-  if (name == "td_requests") {
-    return &VERBOSITY_NAME(td_requests);
-  }
-  if (name == "dc") {
-    return &VERBOSITY_NAME(dc);
-  }
-  if (name == "files") {
-    return &VERBOSITY_NAME(files);
-  }
-  if (name == "mtproto") {
-    return &VERBOSITY_NAME(mtproto);
-  }
-  if (name == "raw_mtproto") {
-    return &VERBOSITY_NAME(raw_mtproto);
-  }
-  if (name == "fd") {
-    return &VERBOSITY_NAME(fd);
-  }
-  if (name == "actor") {
-    return &VERBOSITY_NAME(actor);
-  }
-  if (name == "buffer") {
-    return &VERBOSITY_NAME(buffer);
-  }
-  if (name == "sqlite") {
-    return &VERBOSITY_NAME(sqlite);
+td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::setLogVerbosityLevel &request) {
+  auto result = Logging::set_verbosity_level(static_cast<int>(request.new_verbosity_level_));
+  if (result.is_ok()) {
+    return td_api::make_object<td_api::ok>();
+  } else {
+    return make_error(400, result.message());
   }
-  return nullptr;
 }
 
-void Td::on_request(uint64 id, td_api::testSetLogTagVerbosityLevel &request) {
-  UNREACHABLE();
+td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::getLogVerbosityLevel &request) {
+  return td_api::make_object<td_api::logVerbosityLevel>(Logging::get_verbosity_level());
 }
 
-td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::testSetLogTagVerbosityLevel &request) {
-  int *level = get_log_verbosity_level(request.tag_);
-  if (level == nullptr) {
-    return td_api::make_object<td_api::error>(400, "Log tag is not found");
+td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::getLogTags &request) {
+  return td_api::make_object<td_api::logTags>(Logging::get_tags());
+}
+
+td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::setLogTagVerbosityLevel &request) {
+  auto result = Logging::set_tag_verbosity_level(request.tag_, static_cast<int>(request.new_verbosity_level_));
+  if (result.is_ok()) {
+    return td_api::make_object<td_api::ok>();
+  } else {
+    return make_error(400, result.message());
+  }
+}
+
+td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::getLogTagVerbosityLevel &request) {
+  auto result = Logging::get_tag_verbosity_level(request.tag_);
+  if (result.is_ok()) {
+    return td_api::make_object<td_api::logVerbosityLevel>(result.ok());
+  } else {
+    return make_error(400, result.error().message());
   }
-  *level = clamp(static_cast<int>(request.new_verbosity_level_), 1, VERBOSITY_NAME(NEVER));
+}
 
-  return td_api::make_object<td_api::ok>();
+// test
+void Td::on_request(uint64 id, td_api::testNetwork &request) {
+  create_handler<TestQuery>(id)->send();
+}
+
+void Td::on_request(uint64 id, td_api::testGetDifference &request) {
+  updates_manager_->get_difference("testGetDifference");
+  send_closure(actor_id(this), &Td::send_result, id, make_tl_object<td_api::ok>());
 }
 
 void Td::on_request(uint64 id, td_api::testUseUpdate &request) {