高性能服务器---日志系统

最新推荐文章于 2024-05-24 09:20:47 发布
最新推荐文章于 2024-05-24 09:20:47 发布
阅读量230 收藏
点赞数 1
文章标签： 服务器 windows linux ubuntu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63440562/article/details/131902557
版权

日志系统采用字符串解析进行日志消息的输出，基于日志级别，当前采用的是DEBUG，调用util.h间接调用syscall系统调用进行tid的输出，当然也可以采用系统调用函数syscall(SYS_gettid)。时间采用localtime_t 可重入版本进行时间戳的转换为时间的格式。代码如下，test.cc是测试文件

log.h

#ifndef _LOG_H__
#define _LOG_H__
#include<string>
#include<cstdint>
#include<iostream>
#include<vector>
#include<memory>
#include<list>
#include<fstream>  //文件流
#include<sstream>
#include<time.h>
#include<string.h>
//#include<stringstream>  //字符串流

namespace moxue{

		//提前声明 
		class Logger;
		//日志事件
		class LogEvent{
				public:
						typedef std::shared_ptr<LogEvent> ptr;
						LogEvent(const char* file,int32_t line,uint32_t elapse,uint32_t thread_id,uint32_t fiber_id,uint64_t time);

						const char* getFile() const {return m_file; }
						int32_t getLine() const {return m_line; }
						uint32_t getElapse() const {return m_elapse; }
						uint32_t getthread_id() const { return m_threadid; }
						uint32_t getfiber_id() const { return m_fiberid; }
						uint32_t gettime() const { return m_time; }
						std::string getcontent() const { return m_ss.str(); }

						std::stringstream & getSS() { return m_ss; }
				private:
						const char* m_file=nullptr; //文件名
						int32_t m_line=0;//行号
						uint32_t m_elapse=0; //程序启动开始到现在的毫秒数
						uint32_t m_threadid=0;//线程id
						uint32_t m_fiberid=0;//协程号id
						uint32_t m_time;//时间戳
						//std::string m_content;//信息
						std::stringstream m_ss;
		};
		//日志级别
		class LogLevel{
				public:
						//日志级别
						enum Level{
								DEBUG=1,
								INFO,
								WARN,
								ERROR,
								FATAL
						};
						static const char* ToString(LogLevel::Level level);
		};

		//日志格式器
		class LogFormatter{
				public:
						typedef std::shared_ptr<LogFormatter> ptr;
						LogFormatter(const std::string & pattern); //根据pattern的格式解析items的信息

						std::string format(std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event);
				public:
						class FormatItem{ //日志格式项
						public:
							typedef std::shared_ptr<FormatItem> ptr;		
							//FormatItem(const std::string & str){}	
							virtual ~FormatItem() {};
							virtual void  format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) = 0;
						};

						class MessageFormatItem : public FormatItem{
							public:
								MessageFormatItem(const std::string &str){
									
								}
							 	void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
						};

						class LevelFormatItem : public FormatItem{
							public:
								LevelFormatItem(const std::string &str){

								}
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
						};

						class ElapseFormatItem : public FormatItem{
							public:
								ElapseFormatItem(const std::string &str){

								}
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
						};

						class ThreadidFormatItem : public FormatItem{
							public:
								ThreadidFormatItem(const std::string &str){

								}
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
						};

						class FiberidFormatItem : public FormatItem{
							public:
								FiberidFormatItem(const std::string &str){

								}
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
						};

						class DateTimeFormatItem : public FormatItem{
							public:
								DateTimeFormatItem(const std::string& format = "%Y:%m:%d %H:%M:%s")
									:m_format(format){
										if(m_format.empty()){
											m_format="%Y-%m-%d %H:%M:%S";
										}
									} //默认的时间格式
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
							private:
								std::string m_format;
						};

						class FilenameFormatItem : public FormatItem{
							public:
								FilenameFormatItem(const std::string &str){

								}
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
						};

						class LineFormatItem : public FormatItem{
							public:
								LineFormatItem(const std::string &str){

								}
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
						};

						class NewLineFormatItem : public FormatItem{
							public:
								NewLineFormatItem(const std::string &str){
									
								}
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
						};

						class StringFormatItem : public FormatItem{
							public:
								StringFormatItem(const std::string &str)
									:m_string(str){

									}
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
							private:
								std::string m_string;
						};

						class TabFormatItem : public FormatItem{
							public:
								TabFormatItem(const std::string& str=""){} //常量引用绑定到常量对象
								void format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
						};

						void init(); //init做pattern的解析
				private:
						std::string m_pattern; //模式 
						std::vector<FormatItem::ptr> m_items;
		}; 

		//日志输出地
		class LogAppender{
				public:
						typedef std::shared_ptr<LogAppender> ptr;
						virtual ~LogAppender() {} //因为日志输出地有很多 存在继承关系
						virtual	void log(std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) = 0; //纯虚函数 子类必须实现
						void setFormattwer(LogFormatter::ptr val) { m_formatter=val; } //设置Formatter
						LogFormatter::ptr getFormatter() const { return m_formatter; }													
				protected:
						LogFormatter::ptr m_formatter;
						LogLevel::Level m_level=LogLevel::DEBUG;
		};


		//日志器
		class Logger : public std::enable_shared_from_this<Logger>{
				public:
						typedef std::shared_ptr<Logger> ptr;
						Logger(const std::string name= "root" );
						void log(LogLevel::Level level,LogEvent::ptr event);
						void debug(LogEvent::ptr event);
						void debug(LogLevel::Level level,LogEvent::ptr event);
						void info(LogEvent::ptr event);
						void warn(LogEvent::ptr event);
						void error(LogEvent::ptr event);
						void fatal(LogEvent::ptr event);
						//添加Appender
						void addAppender(LogAppender::ptr appender);
						void delAppender(LogAppender::ptr appender);
						LogLevel::Level getlevel() const { return m_level;  }
						void setlevel(LogLevel::Level val) { m_level=val; }

						const std::string get_name() const { return m_name; }
				private:
						std::string m_name;     					    //日志名称
						LogLevel::Level m_level;					    //满足这个级别的日志才会输出到里面去
						std::list<LogAppender::ptr> m_apperders;        //Appender集合
						LogFormatter::ptr m_formatter;
		};

		//输出到控制台的Appender
		class StdoutLogAppender : public LogAppender{
		public:
				typedef std::shared_ptr<StdoutLogAppender> ptr;//StdoutLogAppender实例化对象的ptr  ptr是类型
				 virtual void log(std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;//参数1：日志级别  参数2：日志事件											 

		};
		//输出到文件的Appender
		class FileLogAppender : public LogAppender{
		public:
				typedef std::shared_ptr<FileLogAppender> ptr;
				 virtual void log(std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event) override;
				 FileLogAppender(const std::string filename);
				bool reopen(); //如果文件已经打开，我们进行关闭并再次打开  重新打开成功返回true 

		private:
				 std::ofstream m_filestream;
				 std::string m_filename;
		};

}

#endif

log.cc

#include"log.h"
#include<ctype.h>
#include<map>
#include<functional>

/*#--宏定义中，将后面的内容进行字符串化*/

namespace  moxue{

		const  char* LogLevel::ToString(LogLevel::Level level){
				switch (level)
				{
		#define XX(name) \
			case LogLevel::name: \
				return #name; \
				break;
				
				XX(DEBUG);
				XX(INFO);
				XX(WARN);
				XX(ERROR);
				XX(FATAL);

		#undef XX
				default:
					return "UNKNOW";
				}
				return "UNKNOW";
		}

	LogEvent::LogEvent(const char* file,int32_t line,uint32_t elapse,uint32_t thread_id,uint32_t fiber_id,
	uint64_t time):m_file(file),m_elapse(elapse),m_fiberid(fiber_id),m_line(line),m_threadid(thread_id),m_time(time)
	{

	}


		Logger::Logger(const std::string name):m_name(name),m_level(LogLevel::DEBUG){
				m_formatter.reset(new LogFormatter("%d%T%t%T%F%T[%p]%T[%c]%T%f:%l%T%m%n"));
		}
		void Logger::log(LogLevel::Level level,LogEvent::ptr event){
				if(level>=m_level){
						auto self=shared_from_this(); //在自己的成员函数中获取自己的指针
						for(auto & i: m_apperders){
								i->log(self,level,event); //
						}
				}
		}

		void  Logger::debug(LogEvent::ptr event){

				log(LogLevel::DEBUG,event);
		}

		void Logger::info(LogEvent::ptr event){

				log(LogLevel::INFO,event);
		}
		void Logger::warn(LogEvent::ptr event){

				log(LogLevel::WARN,event);
		}
		void Logger::error(LogEvent::ptr event){

				log(LogLevel::ERROR,event);
		}
		void Logger::fatal(LogEvent::ptr event){

				log(LogLevel::FATAL,event);
		}


		void Logger::addAppender(LogAppender::ptr appender){
			if(!appender->getFormatter()){
				appender->setFormattwer(m_formatter); /*如果输出没有Formater的话 将我们自己的formater 保证每一个输出都有
				自己的Formater*/
			}
				m_apperders.push_back(appender);
		}
		void Logger::delAppender(LogAppender::ptr appender){
				for(std::list<LogAppender::ptr>::iterator it=m_apperders.begin();it!=m_apperders.end();++it){
						if(*it==appender){
								m_apperders.erase(it);
								break;
						}
				}
		}

		FileLogAppender::FileLogAppender(const std::string filename):m_filename(filename){
			
		}


		void  StdoutLogAppender::log(std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			if(level>=m_level){
				std::string str=m_formatter->format(logger,level,event);
				std::cout<<str;//<<std::endl;
			}
	
		}
		void FileLogAppender::log(std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			if(level>=m_level){
				m_filestream << m_formatter->format(logger,level,event)<<std::endl;  
			}
		}

		bool FileLogAppender::reopen(){
			if(m_filestream){ //如果是已经打开的
				m_filestream.close();
			}	
			m_filestream.open(m_filename);
			return !!m_filestream;
		}

		std::string LogFormatter::format(std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
				std::stringstream ss;
				//std::cout<<"此时的m_items的大小为"<<m_items.size()<<std::endl;
				for(auto & i : m_items){
					i->format(ss,logger,level,event);
				}
				return ss.str();
		}

		LogFormatter::LogFormatter(const std::string & pattern)
				:m_pattern(pattern) {
					init();
		}

		void LogFormatter::init(){ //解析日志输出
				//str format type
				std::vector<std::tuple<std::string,std::string,int>> vec; //tuple (string string int)
				std::string nstr;
				for(size_t i=0;i<m_pattern.size();++i){ //m_pattern是一个模式string
					if(m_pattern[i]!='%'){ 
						nstr.append(1,m_pattern[i]);//追加一个字
					    continue;
					}

					if((i+1)<m_pattern.size()){  //%%
						if(m_pattern[i+1]=='%'){
							nstr.append(1,'%');
						continue;
						}
					}

					size_t n=i+1;
					size_t fmt_begin=0;
					int format_status=0;//格式状态
					std::string fmt;
					std::string str;
					while(n<m_pattern.size()){
						if(!std::isalpha(m_pattern[n]) && m_pattern[n]!='{' &&
								m_pattern[n]!='}'){ //只接受字母
							str=m_pattern.substr(i+1,n-i-1);
							break; //日志格式出现非法字符 直接break
						}
						if(format_status == 0){ //尚未遇到{
							if(m_pattern[n] == '{'){
								str=m_pattern.substr(i+1,n-i-1);
								format_status = 1; //解析格式
								fmt_begin=n;
								++n;
								continue; 
							}		
						}

						else if (format_status==1)
						{
							if(m_pattern[n]== '}' ){
								fmt=m_pattern.substr(fmt_begin+1,n-fmt_begin-1);
								format_status=0;   // /   /==2代表{}字符匹配结束
								++n;
								break;
							}
						}
						++n;
						if(n==m_pattern.size()){
							if(str.empty()){
								str=m_pattern.substr(i+1);
							}
						}
					}

					if(format_status==0){
						if(!nstr.empty()){
							vec.push_back(std::make_tuple(nstr,std::string(),0));
							nstr.clear(); //删除nstr  将空间的首字符置为0
						}
						//str=m_pattern.substr(i+1,n-i-1);
						vec.push_back(std::make_tuple(str,fmt,1));
						i=n-1;
					}
					//格式错误
					else if(format_status==1){
						std::cout<<"pattern parse error "<<m_pattern<<" - "<<m_pattern.substr(i)<<std::endl;
						vec.push_back(std::make_tuple("<<pattern_error>>",fmt,1));
					}
					// else if(format_status==2){
					// 	if(!nstr.empty()){
					// 		vec.push_back(std::make_tuple(nstr,"",0));
					// 		nstr.clear();
					// 	}
					// 	vec.push_back(std::make_tuple(str,fmt,1));
					// 	i=n-1;
					// }

				}
				if(!nstr.empty()){
					vec.push_back(std::make_tuple(nstr,"",0));
				}

	
			
			const std::string m="m",p="p",c="c",r="r",t="t",n="n",d="d",l="l",f="f",T="T",F="F";
			static std::map<std::string,std::function<FormatItem::ptr (const std::string & str)>>
			 s_format_items = {
	#define XX(str,C) { \
		str,[](const std::string & fmt){ return FormatItem::ptr(new C(fmt)); } \
		}

				XX(f,FilenameFormatItem),
				XX(m,MessageFormatItem),
				XX(p,LevelFormatItem),
				XX(r,ElapseFormatItem),
				XX(c,FilenameFormatItem),
				XX(t,ThreadidFormatItem),
				XX(n,NewLineFormatItem),
				XX(d,DateTimeFormatItem),
				XX(l,LineFormatItem),
				XX(T,TabFormatItem),
				XX(F,FiberidFormatItem)
	#undef XX //取消定义宏
			};
			/*%m --消息体
			  %p --level
			  %r --启动后的时间
			  %c --日志名称
			  %t --线程id
			  %n --回车换行
			  %d --时间
			  %f --文件名
			  %l --行号*/

		for(auto & i : vec){
			if(std::get<2>(i)==0){ //string
				m_items.push_back(FormatItem::ptr(new StringFormatItem(std::get<0>(i))));
			}
			else{
				auto it = s_format_items.find(std::get<0>(i));
				if(it == s_format_items.end()){
					m_items.push_back(FormatItem::ptr(new StringFormatItem("<<error_format %"+
					std::get<0>(i)+">>")));
				}
				else{
					m_items.push_back(it->second(std::get<1>(i)));
				}
			}
			//std::cout<<"{"<<std::get<0>(i)<<"} - {"<<std::get<1>(i)<<"} - {"<<std::get<2>(i)<<"}"<<std::endl;
		}
		//std::cout<<"size="<<m_items.size()<<std::endl;
		
		}

	void LogFormatter::MessageFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event)
	{
			os<<event->getcontent();
	}//直接输出event里面

	void LogFormatter::LevelFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			os<<LogLevel::ToString(level);
	}

	void LogFormatter::ElapseFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			os<<event->getElapse();
	}

	void LogFormatter::ThreadidFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			os<<event->getthread_id();
	}
	void LogFormatter::FiberidFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			os<<event->getfiber_id();
	}

	void LogFormatter::DateTimeFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			struct tm tm;
			time_t time=event->gettime();
			localtime_r(&time,&tm);
			char buf[1024];
			strftime(buf,sizeof buf,m_format.c_str(),&tm);

			os<<buf;
	}
	
	void LogFormatter::FilenameFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			os<<event->getFile();
	}

	void LogFormatter::LineFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			os<<" "<<event->getLine();
	}

	void LogFormatter::NewLineFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			os<<std::endl;
	}


	void LogFormatter::StringFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			os<<m_string;
	}


	void LogFormatter::TabFormatItem::format(std::ostream & os,std::shared_ptr<Logger> logger,LogLevel::Level level,LogEvent::ptr event){
			os<<"\t";
	}
}

test.cc

#include<iostream>
#include"../src/log.h"
#include"../src/util.h"
/*输出是通过Logger本体进行输出的*/
#include<thread>
int main(){
	moxue::Logger::ptr logger(new moxue::Logger);
    logger->addAppender(moxue::LogAppender::ptr(new moxue::StdoutLogAppender));

 //   moxue::LogEvent::ptr event(new moxue::LogEvent(__FILE__,__LINE__,0,1,2,time(0)));
    
    // std::thread::id threadId = std::this_thread::get_id();
    // size_t threadIdHash = std::hash<std::thread::id>{}(threadId);
    // int threadIdInt = static_cast<int>(threadIdHash);

    moxue::LogEvent::ptr event(new moxue::LogEvent(__FILE__, __LINE__, 0, moxu::GetThread_Id(), 2, time(0)));

    event->getSS()<<"Hello moxue log"<<std::endl;

    logger->log(moxue::LogLevel::DEBUG,event);

   // std::cout<<"The log is successed"<<std::endl;

    return 0;
}

注：ununtu环境下使用syscall系统函数包含zconf.h或者unistd.h即可，centos 下应该是只有unistd.h

无妨无妨
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
项目---日志系统
南猿北者博客
08-27 1672
本项目实现的是一个多日志器的日志系统，说白了也就是多种类型的日志器，程序员可以通过使用我们的日志器来将指定日志消息按照指定格式和输出等级写入到指定位置！ 程序员再使用我们日志器的时候只需要初始化好日志器的格式化方式、日志输出等级、日志的实际落地方向、以及日志器的类型(同步写日志/异步写日志)就可以了，之后就可以使用我们的日志器输出日志消息了；以上是几个大模块，当然不排除在实际开发过程中需要我们在细分几个小模块出来！ 以下是几个模块交互的简图: 注意我们所实现的日志系统是能在Linux和Windows平台下都
linux————ELK（日志收集系统集群）
a872182042的博客
08-30 2190
日志对于分析系统、应用的状态十分重要，但一般日志的量会比较大，并且比较分散。如果管理的服务器或者程序比较少的情况我们还可以逐一登录到各个服务器去查看、分析。但如果服务器或者程序的数量比较多了之后这种方法就显得力不从心。基于此，一些集中式的日志系统也就应用而生。目前比较有名成熟的有，Splunk(商业)、FaceBook 的Scribe、Apache的Chukwa Cloudera的Fluentd、还有ELK等等。
ELK、ELFK 日志分析系统
最新发布
这里没有简介
05-24 1138
输入采用标准输入，输出采用标准输出（类似管道）#执行 ctrl+c 退出#使用 rubydebug 输出详细格式显示，codec 为一种编解码器#使用 Logstash 将信息写入 Elasticsearch 中结果不在标准输出显示，而是发送至 Elasticsearch 中，可浏览器访问 http://172.168.1.11:9100/ 查看索引信息和数据浏览。Logstash 配置文件基本由三部分组成：input、output 以及 filter（可选，根据需要选择使用）。
日志分析系统——ELK
x74188的博客
10-21 705
ELK是由 ElasticSearch、Logstash 和 Kiabana 三个开源工具所组成， 完成更强大的用户对日志的查询、排序、统计需求。
ELK 企业级日志分析系统
q1y2y3的博客
07-11 1906
ELK平台是一套完整的日志集中处理解决方案，将 ElasticSearch、Logstash 和 Kiabana 三个开源工具配合使用， 完成更强大的用户对日志的查询、排序、统计需求。input {file{#path表示要收集的日志的文件位置#type是输入ES时给结果增加一个叫type的属性字段#start_position可以设置为beginning或者end，beginning表示从头开始读取文件，end表示读取最新的，这个要和ignore_older一起使用。
日志服务器的搭建
m0_50818626的博客
05-11 3928
loganalyzer获取客户端日志会有两种保存模式，一种是直接读取客户端/var/log目录下的日志并保存到服务端该目录下，一种是读取后保存日志服务器数据库中，这里测试的是mariadb数据库。//设置root密码为admin123。DocumentRoot "/loganalyzer" //约119行，改为"/loganalyzer" 原为/var/www/html。<Directory "/loganalyzer"> //约131行，改为"/loganalyzer" 原为/var/www/html。
Linux日志文件服务器搭建
不知道
05-17 1121
我们要做的是让一台主机当成【日志文件服务器】，用来记录另一台Linux主机的信息，这样之间进入一台主机就可以了。
Go-go高性能游戏服务器框架
08-14
总结，《Go-go高性能游戏服务器框架》是结合Go语言特性打造的一款专业级游戏服务器解决方案，它通过分布式系统、高效网络通信和强大的状态管理，为开发者提供了一个高效、稳定的开发环境，助力实现高质量的网络游戏...
cpp-用C11编写的高性能Web服务器
08-16
在本项目中，"cpp-用C11编写的高性能Web服务器"是一个使用现代C++11标准构建的高效Web服务器。这个服务器设计的核心目标是处理HTTP协议中的GET和HEAD请求，提供静态资源服务，同时支持HTTP长连接和请求的管线化。除...
cpp-TANK一个高性能的分布式日志服务
08-15
总的来说，cpp-TANK是一个强大的工具，它通过高性能、分布式的设计，为企业构建了一套可靠且高效的日志管理系统。无论是在大型互联网公司还是中小型企业，cpp-TANK都能成为提升运维效率、优化服务体验的重要助手。...
ANS-Nginx性能测试.docx
10-22
在当前的IT领域，服务器性能的优化至关重要，特别是对于高并发场景下的Web服务。本文将详细探讨一个特定的性能测试案例——ANS-Nginx的性能测试，旨在理解其在不同配置和环境下的表现，并提供可能的优化策略。 一、...
PHP-FPM实现性能优化
10-22
7. **监控工具**：使用系统监控工具（如`top`、`htop`、`iftop`、`sysstat`等）监控服务器性能，及时发现并解决问题。 8. **定期更新**：保持PHP和PHP-FPM的版本更新，获取最新的性能优化和安全修复。 通过以上...
Linux日志系统_syslog服务详解
a1809032425的博客
11-02 5805
linux日志
C++高性能服务器（sylar）日志系统
qq_48185092的博客
10-23 502
最近学完了C++的基础部分，找了个服务器的项目，跟着sylar大佬搭建服务器，这个项目有点难，单是一个日志系统，视频总共才4个小时，我花了一周多的时间才完成，不过在这一周里学到的东西确实很多，一方面是将前面学的基础知识应用到项目中，这段过程个人感觉很重要，这就像是学英语，虽然单词全背会了，但真正在阅读理解中遇到的时候，还是记不到单词的意思。另一方面，跟着大佬敲代码，也渐渐养成了一种良好的编码习惯，以及学到了很多没学过的知识。
C# 超高速高性能写日志（代码开源）
weixin_68436326的博客
07-15 221
来源：Emrys5cnblogs.com/emrys5/p/6693454.html一、需求需求很简单，就是在C#开发中高速写日志。比如在高并发，高流量的地方需要写日志。我们知道程序在操作磁盘时是比较耗时的，所以我们把日志写到磁盘上会有一定的时间耗在上面，这些并不是我们想看到的。二、解决方案2.1、简单原理说明使用列队先缓存到内存，然后我们一直有个线程再从列队中写到磁盘上，这样就可以高速高性能的写...
日志服务管理
LIUKANGYYDS的博客
10-24 544
日志服务管理及配置
开源服务器日志审计系统,开源日志管理系统
weixin_36322275的博客
08-12 4061
开源日志管理系统 内容精选换一换在Log窗口的System Log页签里，您可以查看系统运行日志，操作步骤如下：MindStudio不支持通过界面方式删除设备上的system log日志。如需对日志进行管理，请使用root用户登录到设备侧，对/var/log/npu/slog目录下日志进行管理操作。进行系统日志查看前，需要已添加Device设备，才能获取到Device设已成功登录Java性能分析。...
华为日志服务器系统,服务器日志管理系统
weixin_39964819的博客
08-12 689
服务器日志管理系统 内容精选换一换在Log窗口的System Log页签里，您可以查看系统运行日志，操作步骤如下：Mind Studio不支持通过界面方式删除设备上的system log日志。如需对日志进行管理，请使用root或Mind Studio安装用户登录Mind Studio所在服务器操作系统后对/var/dlog目录下日志进行管理操作；如果Mind StudioManager的审计日志默...
一种服务器日志管理方法及系统
baidu_24932821的博客
06-03 3128
摘要 本发明提供一种服务器日志管理方法及系统，所述方法包括：初始化软件界面，连接数据库；读取并分解由服务程序的输出所生成的记录，以提取所述记录的特征参数；所述分解为将所述记录分解成时间、时间类型、产生位置及事件内容中的一种或多种；当所述特征参数与预设参数一致时，将所述记录保存到所述数据库中；反之，丢弃所述记录。本发明解决了服务器大量日志难以维护的问题，操作简单、效率高。 说明
Redis详解.docx
09-05
"Redis是一个高性能的key-value数据库，与Memcached相似但提供了更多数据类型，如string、list、set和zset，支持丰富的操作且具备原子性。Redis还支持数据持久化和master-slave同步，而Memcached通常不保存到磁盘。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值