AI 助理
备案控制台
开发者社区 安全 文章 正文

同时具备多线程和多进程安全的写日志工具

2015-05-04 722
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 接口请浏览：https://github.com/eyjian/mooon/blob/master/mooon/include/mooon/sys/log.h 实现头文件请浏览：https://github.
接口请浏览： https://github.com/eyjian/mooon/blob/master/mooon/include/mooon/sys/log.h
实现头文件请浏览： https://github.com/eyjian/mooon/blob/master/mooon/include/mooon/sys/safe_logger.h

测试代码： https://github.com/eyjian/mooon/blob/master/mooon/test/sys/test_safe_logger.cpp

使用示例：
MYLOG_DEBUG("[%d]MMMMM", 2015);

支持自动添加换行符，默认会自动添加换行符，但可以禁止自动添加换行符。还支持自动在行尾添加点号等功能。

下面是 实现：

  1. #include "mooon/sys/safe_logger.h"
  2. #include "mooon/sys/datetime_utils.h"
  3. #include "mooon/sys/file_locker.h"
  4. #include "mooon/sys/file_utils.h"
  5. #include "mooon/utils/scoped_ptr.h"
  6. #include "mooon/utils/string_utils.h"
  7. #include libgen.h>
  8. #include pthread.h>
  9. #include sstream>
  10. #include syslog.h>
  11. #include unistd.h>

  13. #define WRITE_SYSLOG 0 // 出错时是否记录系统日志，1表示记录
  14. SYS_NAMESPACE_BEGIN

  16. // 线程级别的
  17. static __thread int sg_thread_log_fd = -1;

  19. CSafeLogger* create_safe_logger(bool enable_program_path, uint16_t log_line_size) throw (CSyscallException)
  20. {
  21.     std::string log_dirpath = get_log_dirpath(enable_program_path);
  22.     std::string log_filename = get_log_filename();
  23.     CSafeLogger* logger = new CSafeLogger(log_dirpath.c_str(), log_filename.c_str(), log_line_size);

  25.     set_log_level_by_env(logger);
  26.     enable_screen_log_by_env(logger);
  27.     enable_trace_log_by_env(logger);
  28.     set_log_filesize_by_env(logger);
  29.     set_log_backup_by_env(logger);

  31.     return logger;
  32. }

  34. CSafeLogger* create_safe_logger(const std::string& log_dirpath, const std::string& cpp_filename, uint16_t log_line_size) throw (CSyscallException)
  35. {
  36.     char* cpp_filepath = strdup(cpp_filename.c_str());
  37.     std::string only_filename = basename(cpp_filepath);
  38.     free(cpp_filepath);

  40.     std::string log_filename = utils::CStringUtils::replace_suffix(only_filename, ".log");
  41.     CSafeLogger* logger = new CSafeLogger(log_dirpath.c_str(), log_filename.c_str(), log_line_size);

  43.     set_log_level_by_env(logger);
  44.     enable_screen_log_by_env(logger);
  45.     enable_trace_log_by_env(logger);
  46.     set_log_filesize_by_env(logger);
  47.     set_log_backup_by_env(logger);

  49.     return logger;
  50. }

  52. ////////////////////////////////////////////////////////////////////////////////
  53. CSafeLogger::CSafeLogger(const char* log_dir, const char* log_filename, uint16_t log_line_size) throw (CSyscallException)
  54.     :_auto_adddot(false)
  55.     ,_auto_newline(true)
  56.     ,_bin_log_enabled(false)
  57.     ,_trace_log_enabled(false)
  58.     ,_raw_log_enabled(false)
  59.     ,_screen_enabled(false)
  60.     ,_log_dir(log_dir)
  61.     ,_log_filename(log_filename)
  62.     ,_log_filepath(_log_dir + std::string("/") + _log_filename)
  63. {
  64.     atomic_set(&_max_bytes, DEFAULT_LOG_FILE_SIZE);
  65.     atomic_set(&_log_level, LOG_LEVEL_INFO);
  66.     atomic_set(&_backup_number, DEFAULT_LOG_FILE_BACKUP_NUMBER);

  68.     // 保证日志行最大长度不小于指定值
  69.     _log_line_size = (log_line_size LOG_LINE_SIZE_MIN)? LOG_LINE_SIZE_MIN: log_line_size;
  70.     if (_log_line_size > LOG_LINE_SIZE_MAX)
  71.         _log_line_size = LOG_LINE_SIZE_MAX;

  73.     int log_fd = open(_log_filepath.c_str(), O_WRONLY|O_CREAT|O_APPEND, FILE_DEFAULT_PERM);
  74.     if (-1 == log_fd)
  75.     {
  76.         int errcode = errno;
  77.         fprintf(stderr, "[%d:%lu] SafeLogger open %s error: %m\n", getpid(), pthread_self(), _log_filepath.c_str());

  79.         THROW_SYSCALL_EXCEPTION(NULL, errcode, "open");
  80.     }
  81.     else
  82.     {
  83.         close(log_fd);
  84.     }
  85. }

  87. CSafeLogger::~CSafeLogger()
  88. {
  89.     (void)release();
  90. }

  92. int CSafeLogger::release()
  93. {
  94.     int ret = 0;
  95.     if (sg_thread_log_fd != -1)
  96.     {
  97. #if 0 // 由系统决定何时fsync
  98.         ret = fsync(sg_thread_log_fd);
  99.         if (-1 == ret)
  100.         {
  101.             fprintf(stderr, "process(%u,%lu) fsync fd(%d) error: %m\n", getpid(), pthread_self(), sg_thread_log_fd);
  102.         }
  103.         else
  104. #endif
  105.         {
  106.             ret = close(sg_thread_log_fd);
  107.             if (0 == ret)
  108.                 sg_thread_log_fd = -1;
  109.             else
  110.                 fprintf(stderr, "process(%u,%lu) close fd(%d) error: %m\n", getpid(), pthread_self(), sg_thread_log_fd);
  111.         }
  112.     }

  114.     return ret;
  115. }

  117. void CSafeLogger::enable_screen(bool enabled)
  118. {
  119.     _screen_enabled = enabled;
  120. }

  122. void CSafeLogger::enable_bin_log(bool enabled)
  123. {
  124.     _bin_log_enabled = enabled;
  125. }

  127. void CSafeLogger::enable_trace_log(bool enabled)
  128. {
  129.     _trace_log_enabled = enabled;
  130. }

  132. void CSafeLogger::enable_raw_log(bool enabled)
  133. {
  134.     _raw_log_enabled = enabled;
  135. }

  137. void CSafeLogger::enable_auto_adddot(bool enabled)
  138. {
  139.     _auto_adddot = enabled;
  140. }

  142. void CSafeLogger::enable_auto_newline(bool enabled)
  143. {
  144.     _auto_newline = enabled;
  145. }

  147. void CSafeLogger::set_log_level(log_level_t log_level)
  148. {
  149.     atomic_set(&_log_level, log_level);
  150. }

  152. void CSafeLogger::set_single_filesize(uint32_t filesize)
  153. {
  154.     uint32_t max_bytes = (filesize LOG_LINE_SIZE_MIN*10)? LOG_LINE_SIZE_MIN*10: filesize;
  155.     atomic_set(&_max_bytes, max_bytes);
  156. }

  158. void CSafeLogger::set_backup_number(uint16_t backup_number)
  159. {
  160.     atomic_set(&_backup_number, backup_number);
  161. }

  163. bool CSafeLogger::enabled_bin()
  164. {
  165.     return _bin_log_enabled;
  166. }

  168. bool CSafeLogger::enabled_detail()
  169. {
  170.     return atomic_read(&_log_level) = LOG_LEVEL_DETAIL;
  171. }

  173. bool CSafeLogger::enabled_debug()
  174. {
  175.     return atomic_read(&_log_level) = LOG_LEVEL_DEBUG;
  176. }

  178. bool CSafeLogger::enabled_info()
  179. {
  180.     return atomic_read(&_log_level) = LOG_LEVEL_INFO;
  181. }

  183. bool CSafeLogger::enabled_warn()
  184. {
  185.     return atomic_read(&_log_level) = LOG_LEVEL_WARN;
  186. }

  188. bool CSafeLogger::enabled_error()
  189. {
  190.     return atomic_read(&_log_level) = LOG_LEVEL_ERROR;
  191. }

  193. bool CSafeLogger::enabled_fatal()
  194. {
  195.     return atomic_read(&_log_level) = LOG_LEVEL_FATAL;
  196. }

  198. bool CSafeLogger::enabled_state()
  199. {
  200.     return atomic_read(&_log_level) = LOG_LEVEL_STATE;
  201. }

  203. bool CSafeLogger::enabled_trace()
  204. {
  205.     return _trace_log_enabled;
  206. }

  208. bool CSafeLogger::enabled_raw()
  209. {
  210.     return _raw_log_enabled;
  211. }

  213. void CSafeLogger::log_detail(const char* filename, int lineno, const char* module_name, const char* format, va_list& args)
  214. {
  215.     if (enabled_detail())
  216.         do_log(LOG_LEVEL_DETAIL, filename, lineno, module_name, format, args);
  217. }

  219. void CSafeLogger::log_detail(const char* filename, int lineno, const char* module_name, const char* format, ...)
  220. {
  221.     if (enabled_detail())
  222.     {
  223.         va_list args;
  224.         va_start(args, format);
  225.         utils::VaListHelper vh(args);

  227.         do_log(LOG_LEVEL_DETAIL, filename, lineno, module_name, format, args);
  228.     }
  229. }

  231. void CSafeLogger::log_debug(const char* filename, int lineno, const char* module_name, const char* format, va_list& args)
  232. {
  233.     if (enabled_detail())
  234.         do_log(LOG_LEVEL_DEBUG, filename, lineno, module_name, format, args);
  235. }

  237. void CSafeLogger::log_debug(const char* filename, int lineno, const char* module_name, const char* format, ...)
  238. {
  239.     if (enabled_debug())
  240.     {
  241.         va_list args;
  242.         va_start(args, format);
  243.         utils::VaListHelper vh(args);

  245.         do_log(LOG_LEVEL_DEBUG, filename, lineno, module_name, format, args);
  246.     }
  247. }

  249. void CSafeLogger::log_info(const char* filename, int lineno, const char* module_name, const char* format, va_list& args)
  250. {
  251.     if (enabled_info())
  252.         do_log(LOG_LEVEL_INFO, filename, lineno, module_name, format, args);
  253. }

  255. void CSafeLogger::log_info(const char* filename, int lineno, const char* module_name, const char* format, ...)
  256. {
  257.     if (enabled_info())
  258.     {
  259.         va_list args;
  260.         va_start(args, format);
  261.         utils::VaListHelper vh(args);

  263.         do_log(LOG_LEVEL_INFO, filename, lineno, module_name, format, args);
  264.     }
  265. }

  267. void CSafeLogger::log_warn(const char* filename, int lineno, const char* module_name, const char* format, va_list& args)
  268. {
  269.     if (enabled_warn())
  270.         do_log(LOG_LEVEL_WARN, filename, lineno, module_name, format, args);
  271. }

  273. void CSafeLogger::log_warn(const char* filename, int lineno, const char* module_name, const char* format, ...)
  274. {
  275.     if (enabled_warn())
  276.     {
  277.         va_list args;
  278.         va_start(args, format);
  279.         utils::VaListHelper vh(args);

  281.         do_log(LOG_LEVEL_WARN, filename, lineno, module_name, format, args);
  282.     }
  283. }

  285. void CSafeLogger::log_error(const char* filename, int lineno, const char* module_name, const char* format, va_list& args)
  286. {
  287.     if (enabled_error())
  288.         do_log(LOG_LEVEL_ERROR, filename, lineno, module_name, format, args);
  289. }

  291. void CSafeLogger::log_error(const char* filename, int lineno, const char* module_name, const char* format, ...)
  292. {
  293.     if (enabled_error())
  294.     {
  295.         va_list args;
  296.         va_start(args, format);
  297.         utils::VaListHelper vh(args);

  299.         do_log(LOG_LEVEL_ERROR, filename, lineno, module_name, format, args);
  300.     }
  301. }

  303. void CSafeLogger::log_fatal(const char* filename, int lineno, const char* module_name, const char* format, va_list& args)
  304. {
  305.     if (enabled_fatal())
  306.         do_log(LOG_LEVEL_FATAL, filename, lineno, module_name, format, args);
  307. }

  309. void CSafeLogger::log_fatal(const char* filename, int lineno, const char* module_name, const char* format, ...)
  310. {
  311.     if (enabled_fatal())
  312.     {
  313.         va_list args;
  314.         va_start(args, format);
  315.         utils::VaListHelper vh(args);

  317.         do_log(LOG_LEVEL_FATAL, filename, lineno, module_name, format, args);
  318.     }
  319. }

  321. void CSafeLogger::log_state(const char* filename, int lineno, const char* module_name, const char* format, va_list& args)
  322. {
  323.     if (enabled_state())
  324.         do_log(LOG_LEVEL_STATE, filename, lineno, module_name, format, args);
  325. }

  327. void CSafeLogger::log_state(const char* filename, int lineno, const char* module_name, const char* format, ...)
  328. {
  329.     if (enabled_state())
  330.     {
  331.         va_list args;
  332.         va_start(args, format);
  333.         utils::VaListHelper vh(args);

  335.         do_log(LOG_LEVEL_STATE, filename, lineno, module_name, format, args);
  336.     }
  337. }

  339. void CSafeLogger::log_trace(const char* filename, int lineno, const char* module_name, const char* format, va_list& args)
  340. {
  341.     if (enabled_trace())
  342.         do_log(LOG_LEVEL_TRACE, filename, lineno, module_name, format, args);
  343. }

  345. void CSafeLogger::log_trace(const char* filename, int lineno, const char* module_name, const char* format, ...)
  346. {
  347.     if (enabled_trace())
  348.     {
  349.         va_list args;
  350.         va_start(args, format);
  351.         utils::VaListHelper vh(args);

  353.         do_log(LOG_LEVEL_TRACE, filename, lineno, module_name, format, args);
  354.     }
  355. }

  357. void CSafeLogger::log_raw(const char* format, va_list& args)
  358. {
  359.     if (enabled_raw())
  360.         do_log(LOG_LEVEL_RAW, NULL, -1, NULL, format, args);
  361. }

  363. void CSafeLogger::log_raw(const char* format, ...)
  364. {
  365.     if (enabled_raw())
  366.     {
  367.         va_list args;
  368.         va_start(args, format);
  369.         utils::VaListHelper vh(args);
  370.         do_log(LOG_LEVEL_RAW, NULL, -1, NULL, format, args);
  371.     }
  372. }

  374. void CSafeLogger::log_bin(const char* filename, int lineno, const char* module_name, const char* log, uint16_t size)
  375. {
  376.     if (enabled_bin())
  377.     {
  378.         std::string str(size*2, '\0');
  379.         char* str_p = const_castchar*>(str.data());
  380.         for (uint16_t i=0; isize; ++i)
  381.         {
  382.             snprintf(str_p, 3, "%02X", (int)log[i]);
  383.             str_p += 2;
  384.         }

  386.         va_list args;
  387.         do_log(LOG_LEVEL_BIN, filename, lineno, module_name, str.c_str(), args);
  388.     }
  389. }

  391. int CSafeLogger::get_thread_log_fd() const
  392. {
  393.     if (-1 == sg_thread_log_fd)
  394.     {
  395.         sg_thread_log_fd = open(_log_filepath.c_str(), O_WRONLY|O_CREAT|O_APPEND, FILE_DEFAULT_PERM);
  396.         if (-1 == sg_thread_log_fd)
  397.             fprintf(stderr, "open %s error: %m\n", _log_filepath.c_str());
  398.     }

  400.     return sg_thread_log_fd;
  401. }

  403. bool CSafeLogger::need_rotate(int fd) const
  404. {
  405.     off_t file_size = CFileUtils::get_file_size(fd);
  406.     return file_size > static_castoff_t>(atomic_read(&_max_bytes));
  407. }

  409. void CSafeLogger::do_log(log_level_t log_level, const char* filename, int lineno, const char* module_name, const char* format, va_list& args)
  410. {
  411.     int log_real_size;
  412.     utils::ScopedArraychar> log_line(new char[_log_line_size]);

  414.     if (LOG_LEVEL_RAW == log_level)
  415.     {
  416.         // fix_vsnprintf()的返回值包含了结尾符在内的长度
  417.         log_real_size = utils::CStringUtils::fix_vsnprintf(log_line.get(), _log_line_size, format, args);
  418.         --log_real_size; // 结尾符不需要写入日志文件中
  419.     }
  420.     else
  421.     {
  422.         std::stringstream log_header; // 每条日志的头
  423.         char datetime[sizeof("2012-12-12 12:12:12/0123456789")];
  424.         get_formatted_current_datetime(datetime, sizeof(datetime));

  426.         // 日志头内容：[日期][线程ID/进程ID][日志级别][模块名][代码文件名][代码行号]
  427.         log_header "[" datetime "]"
  428.                     "[" pthread_self() "/" getpid() "]"
  429.                     "[" get_log_level_name(log_level) "]";
  430.         if (module_name != NULL)
  431.             log_header "[" module_name "]";
  432.         if (filename != NULL)
  433.             log_header "[" utils::CStringUtils::extract_filename(filename) ":" lineno "]";

  435.         int m, n;
  436.         // 注意fix_snprintf()的返回值大小包含了结尾符
  437.         m = utils::CStringUtils::fix_snprintf(log_line.get(), _log_line_size, "%s", log_header.str().c_str());

  439.         if (LOG_LEVEL_BIN == log_level)
  440.             n = utils::CStringUtils::fix_snprintf(log_line.get()+m-1, _log_line_size-m, "%s", format);
  441.         else
  442.             n = utils::CStringUtils::fix_vsnprintf(log_line.get()+m-1, _log_line_size-m, format, args);
  443.         log_real_size = m + n - 2;

  445.         // 是否自动添加结尾用的点号
  446.         if (_auto_adddot)
  447.         {
  448.             // 如果已有结尾的点，则不再添加，以免重复
  449.             if (log_line.get()[log_real_size-1] != '.')
  450.             {
  451.                 log_line.get()[log_real_size] = '.';
  452.                 ++log_real_size;
  453.             }
  454.         }

  456.         // 是否自动换行
  457.         if (_auto_newline)
  458.         {
  459.             // 如果已有一个换行符，则不再添加
  460.             if (log_line.get()[log_real_size-1] != '\n')
  461.             {
  462.                 log_line.get()[log_real_size] = '\n';
  463.                 ++log_real_size;
  464.             }
  465.         }
  466.     }

  468.     // 允许打屏
  469.     if (_screen_enabled)
  470.     {
  471.         (void)write(STDOUT_FILENO, log_line.get(), log_real_size);
  472.     }

  474.     if (false)
  475.     {
  476.         // 异步写入日志文件
  477.         //log_line.release();
  478.     }
  479.     else
  480.     {
  481.         // 同步写入日志文件
  482.         int thread_log_fd = get_thread_log_fd();
  483.         if (thread_log_fd != -1)
  484.         {
  485.             write_log(thread_log_fd, log_line.get(), log_real_size);
  486.         }
  487.         else
  488.         {
  489.             fprintf(stderr, "process(%u,%lu) without thread log\n", getpid(), pthread_self());

  491. #if WRITE_SYSLOG==1
  492.             openlog("mooon-safe-logger", LOG_CONS|LOG_PID, 0);
  493.             syslog(LOG_ERR, "process(%u,%lu) without thread log\n", getpid(), pthread_self());
  494.             closelog();
  495. #endif // WRITE_SYSLOG
  496.         }
  497.     }
  498. }

  500. void CSafeLogger::rotate_log()
  501. {
  502.     std::string new_path; // 滚动后的文件路径，包含目录和文件名
  503.     std::string old_path; // 滚动前的文件路径，包含目录和文件名

  505.     // 历史滚动
  506.     int backup_number = atomic_read(&_backup_number);
  507.     for (int i=backup_number-1; i>1; --i)
  508.     {
  509.         new_path = _log_dir + std::string("/") + _log_filename + std::string(".") + utils::CStringUtils::any2string(static_castint>(i));
  510.         old_path = _log_dir + std::string("/") + _log_filename + std::string(".") + utils::CStringUtils::any2string(static_castint>(i-1));

  512.         if (0 == access(old_path.c_str(), F_OK))
  513.         {
  514.             if (-1 == rename(old_path.c_str(), new_path.c_str()))
  515.                 fprintf(stderr, "[%d:%lu] SafeLogger rename %s to %s error: %m.\n", getpid(), pthread_self(), old_path.c_str(), new_path.c_str());
  516.         }
  517.         else
  518.         {
  519.             if (errno != ENOENT)
  520.                 fprintf(stderr, "[%d:%lu] SafeLogger access %s error: %m.\n", getpid(), pthread_self(), old_path.c_str());
  521.         }
  522.     }

  524.     if (backup_number > 0)
  525.     {
  526.         // 当前滚动
  527.         new_path = _log_dir + std::string("/") + _log_filename + std::string(".1");
  528.         if (0 == access(_log_filepath.c_str(), F_OK))
  529.         {
  530.             if (-1 == rename(_log_filepath.c_str(), new_path.c_str()))
  531.                 fprintf(stderr, "[%d:%lu] SafeLogger rename %s to %s error: %m\n", getpid(), pthread_self(), _log_filepath.c_str(), new_path.c_str());
  532.         }
  533.         else
  534.         {
  535.             if (errno != ENOENT)
  536.                 fprintf(stderr, "[%d:%lu] SafeLogger access %s error: %m\n", getpid(), pthread_self(), _log_filepath.c_str());
  537.         }
  538.     }

  540.     // 重新创建
  541.     //fprintf(stdout, "[%d:%lu] SafeLogger create %s\n", getpid(), pthread_self(), _log_filepath.c_str());
  542.     int new_log_fd = open(_log_filepath.c_str(), O_WRONLY|O_CREAT|O_APPEND, FILE_DEFAULT_PERM); // O_EXCL
  543.     if (new_log_fd != -1)
  544.     {
  545.         sg_thread_log_fd = new_log_fd;
  546.     }
  547.     else
  548.     {
  549.         fprintf(stderr, "[%d:%lu] SafeLogger create %s error: %m\n", getpid(), pthread_self(), _log_filepath.c_str());

  551. #if WRITE_SYSLOG==1
  552.         openlog("mooon-safe-logger", LOG_CONS|LOG_PID, 0);
  553.         syslog(LOG_ERR, "[%d:%lu] SafeLogger create %s error: %m\n", getpid(), pthread_self(), _log_filepath.c_str());
  554.         closelog();
  555. #endif // WRITE_SYSLOG
  556.     }
  557. }

  559. void CSafeLogger::write_log(int thread_log_fd, const char* log_line, int log_line_size)
  560. {
  561.     int bytes = write(thread_log_fd, log_line, log_line_size);
  562.     if (-1 == bytes)
  563.     {
  564.         fprintf(stderr, "[%d:%lu] SafeLogger[%d] write error: %m\n", getpid(), pthread_self(), thread_log_fd);
  565.     }
  566.     else if (0 == bytes)
  567.     {
  568.         fprintf(stderr, "[%d:%lu] write nothing: SafeLogger[%d]\n", getpid(), pthread_self(), thread_log_fd);
  569.     }
  570.     else if (bytes > 0)
  571.     {
  572.         try
  573.         {
  574.             // 判断是否需要滚动
  575.             if (need_rotate(thread_log_fd))
  576.             {
  577.                 std::string lock_path = _log_dir + std::string("/.") + _log_filename + std::string(".lock");
  578.                 FileLocker file_locker(lock_path.c_str(), true); // 确保这里一定加锁

  580.                 // _fd可能已被其它进程或线程滚动了，所以这里需要重新open一下
  581.                 int new_log_fd = open(_log_filepath.c_str(), O_WRONLY|O_CREAT|O_APPEND, FILE_DEFAULT_PERM);
  582.                 if (-1 == new_log_fd)
  583.                 {
  584.                     fprintf(stderr, "[%d:%lu] SafeLogger open %s error: %m\n", getpid(), pthread_self(), _log_filepath.c_str());
  585.                 }
  586.                 else
  587.                 {
  588.                     try
  589.                     {
  590.                         release();

  592.                         if (!need_rotate(new_log_fd))
  593.                         {
  594.                             // 其它进程或线程抢先做了滚动
  595.                             sg_thread_log_fd = new_log_fd;
  596.                         }
  597.                         else
  598.                         {
  599.                             close(new_log_fd);
  600.                             rotate_log();
  601.                         }
  602.                     }
  603.                     catch (CSyscallException& syscall_ex)
  604.                     {
  605.                         fprintf(stderr, "[%d:%lu] SafeLogger[%d] rotate error: %s.\n", getpid(), pthread_self(), new_log_fd, syscall_ex.str().c_str());
  606.                     }
  607.                 }
  608.             }
  609.         }
  610.         catch (CSyscallException& syscall_ex)
  611.         {
  612.             fprintf(stderr, "[%d:%lu] SafeLogger[%d] rotate error: %s\n", getpid(), pthread_self(), thread_log_fd, syscall_ex.str().c_str());
  613.         }
  614.     }
  615. }

  617. SYS_NAMESPACE_END





文章标签：
日志服务
安全
监控
关键词：
线程进程
日志服务工具
多进程日志服务
进程日志服务
线程安全
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
一见蓝天
目录
相关文章
请看我回答~
|
7天前
|
UED 开发者 Python
探索操作系统的心脏：理解进程与线程
【8月更文挑战第31天】在数字世界的海洋中，操作系统犹如一艘巨轮，其稳定航行依赖于精密的进程与线程机制。本文将揭开这一机制的神秘面纱，通过深入浅出的语言和直观的代码示例，引领读者从理论到实践，体验进程与线程的魅力。我们将从基础概念出发，逐步深入到它们之间的联系与区别，最后探讨如何在编程实践中高效运用这些知识。无论你是初学者还是有经验的开发者，这篇文章都将为你的技术之旅增添新的航标。
请看我回答~
17 2
李木子2024
|
13天前
|
Java 程序员 调度
【JAVA 并发秘籍】进程、线程、协程：揭秘并发编程的终极武器！
【8月更文挑战第25天】本文以问答形式深入探讨了并发编程中的核心概念——进程、线程与协程，并详细介绍了它们在Java中的应用。文章不仅解释了每个概念的基本原理及其差异，还提供了实用的示例代码，帮助读者理解如何在Java环境中实现这些并发机制。无论你是希望提高编程技能的专业开发者，还是准备技术面试的求职者，都能从本文获得有价值的见解。
李木子2024
31 1
奔跑的数据
|
11天前
|
数据采集 存储 安全
如何确保Python Queue的线程和进程安全性：使用锁的技巧
本文探讨了在Python爬虫技术中使用锁来保障Queue（队列）的线程和进程安全性。通过分析`queue.Queue`及`multiprocessing.Queue`的基本线程与进程安全特性，文章指出在特定场景下使用锁的重要性。文中还提供了一个综合示例，该示例利用亿牛云爬虫代理服务、多线程技术和锁机制，实现了高效且安全的网页数据采集流程。示例涵盖了代理IP、User-Agent和Cookie的设置，以及如何使用BeautifulSoup解析HTML内容并将其保存为文档。通过这种方式，不仅提高了数据采集效率，还有效避免了并发环境下的数据竞争问题。
奔跑的数据
32 1
如何确保Python Queue的线程和进程安全性：使用锁的技巧
请看我回答~
|
9天前
|
调度
深入理解操作系统：进程与线程的管理
【8月更文挑战第29天】在数字世界的每一次点击和滑动背后，都隐藏着操作系统的精妙运作。本文将带你探索操作系统的核心概念之一——进程与线程的管理。我们将从基础定义出发，逐步深入到它们在内存中的表示、状态变迁以及它们之间错综复杂的关系。通过简洁明了的语言和直观的比喻，即便是没有计算机背景的读者也能轻松理解这一主题。准备好了吗？让我们一起揭开操作系统神秘的面纱，探索那些看似晦涩却无比精彩的知识吧！
请看我回答~
15 1
请看我回答~
|
11天前
|
调度 Python
深入理解操作系统：进程与线程的奥秘
【8月更文挑战第27天】本文将带你走进操作系统的核心，探索进程和线程这两个基本概念。我们将从它们的定义开始，逐步深入到它们之间的联系和区别，以及在操作系统中的作用。通过本文，你将了解到进程和线程不仅仅是编程中的两个术语，它们是操作系统管理资源、实现并发和并行的关键。最后，我们还将通过一个代码示例，展示如何在Python中创建和管理线程。
请看我回答~
30 3
请看我回答~
|
10天前
|
算法 调度 开发者
深入理解操作系统：进程与线程管理
【8月更文挑战第28天】在数字世界的心脏跳动着的是操作系统，它是计算机硬件与软件之间的桥梁。本文将带你探索操作系统的核心概念——进程与线程，揭示它们如何协同工作以支持多任务处理和并发执行。通过实际代码示例，我们将深入了解这些抽象概念是如何在真实系统中实现的。无论你是编程新手还是资深开发者，这篇文章都将为你提供新的视角，让你对操作系统有更深刻的认识。
请看我回答~
22 1
路边两盏灯
|
14天前
|
Java Windows
【Azure Developer】Windows中通过pslist命令查看到Java进程和线程信息，但为什么和代码中打印出来的进程号不一致呢？
【Azure Developer】Windows中通过pslist命令查看到Java进程和线程信息，但为什么和代码中打印出来的进程号不一致呢？
路边两盏灯
25 1
1387503158665997
|
5天前
crash —— 输出属于同一个进程的所有线程
crash —— 输出属于同一个进程的所有线程
1387503158665997
12 0
请看我回答~
|
6天前
|
调度 开发者 Python
深入浅出操作系统：进程与线程的奥秘
【8月更文挑战第31天】 本文将带你探索操作系统中的核心概念——进程与线程。通过浅显易懂的语言和实际代码示例，我们将一起理解它们的定义、区别以及在操作系统中的作用。无论你是编程新手还是有一定经验的开发者，这篇文章都将为你打开一扇了解计算机内部工作原理的新窗口。
请看我回答~
14 0
李木子2024
|
7天前
|
C# 开发者 数据处理
WPF开发者必备秘籍：深度解析数据网格最佳实践，轻松玩转数据展示与编辑大揭秘！
【8月更文挑战第31天】数据网格控件是WPF应用程序中展示和编辑数据的关键组件，提供排序、筛选等功能，显著提升用户体验。本文探讨WPF中数据网格的最佳实践，通过DevExpress DataGrid示例介绍其集成方法，包括添加引用、定义数据模型及XAML配置。通过遵循数据绑定、性能优化、自定义列等最佳实践，可大幅提升数据处理效率和用户体验。
李木子2024
22 0

热门文章

最新文章

  • 1
    Oracle自动清理日志脚本
  • 2
    Kubernetes全方位日志采集与管理的最佳实践 资料下载
  • 3
    sql server 高可用日志传送
  • 4
    小巧的日志记录组件 - 开源研究系列文章
  • 5
    《日志管理与分析权威指南》一1.4　被低估的日志
  • 6
    05【在线日志分析】之Kafka 0.10.1.0 Cluster的搭建和Topic简单操作实验
  • 7
    Log4j配置文件以及配置方法
  • 8
    Log4Net level优先级别
  • 9
    [日志服务][数据加工]e_output使用总结
  • 10
    linux下清理日志的脚本
  • 1
    【Linux-14】进程地址空间＆虚拟空间＆页表——原理＆知识点详解
    154
  • 2
    【Linux】一文了解【进程优先级相关知识点】＆【PRI / NI值】背后的修正原理（13）
    47
  • 3
    【Linux】深度解析Linux中的几种进程状态
    108
  • 4
    【Linux系列】fork( )函数原理与应用详解——了解【父子进程及其特性】(代码演示，画图帮助理解，思维导图，精简)（11）
    103
  • 5
    【Linux】解决：为什么重复创建同一个【进程pid会变化，而ppid父进程id不变？】
    49
  • 6
    深入理解操作系统中的进程调度策略
    67
  • 7
    构建高效微服务架构：后端开发的新趋势深入理解操作系统之进程调度策略
    74
  • 8
    深入理解Linux内核的进程调度机制
    70
  • 9
    4.进程同步
    40
  • 10
    构筑网络长城：网络安全漏洞解析与防御策略深入理解操作系统：进程管理与调度策略
    46

    • 相关课程

    更多
  • 基于MongoDB构建实时日志分析平台
  • 日志服务SLS实现云产品可观测
  • 日志服务 SLS 可观测数据分析平台介绍
  • 大数据知识图谱系列—基于ELK+Flink日志全观测最佳实践
  • 场景实践-基于阿里云Quick BI 对MOOC网站日志分析

    • 相关电子书

    更多
  • 大规模日志数据平台架构面临的问题与挑战
  • PostgresChina2018_赖思超_PostgreSQL10_hash索引的WAL日志修改版final
  • Kubernetes下日志实时采集、存储与计算实践

    • 相关实验场景

    更多
  • 通过日志服务实现云资源OSS的安全审计
  • 如何将OSS数据导入至SLS中进行分析
  • 日志服务之使用Nginx模式采集日志
  • 观察进程的并发性
  • 揭秘如何通过日志服务实现个人敏感信息保护
    • 下一篇
    DDNS