myvtm/Other/libpublicFun/exLog/skyeyeLog.cpp

#include "skyeyeLog.h"
#include "RestfulFunc.h"
#include "JsonConvertHelper.hpp"
#include "json/json.h"
#include <chrono>
#include <thread>
#include <mutex>
#include "uuid4.h"
#include "SpDefine.h"
#include <list>
#include <cstdarg>



#if (defined _WIN32 || defined _WIN64)
#include <Windows.h>
#include <WinSock.h>
#include <IPHlpApi.h>
#pragma comment(lib, "IPHlpApi.lib")
#pragma comment(lib, "Ws2_32.lib")
#else
#include <winpr/string.h>
#include <netdb.h>
#include <unistd.h>
#include <sys/un.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <net/if.h>
#include <sys/stat.h>
#include <sys/time.h>
#endif

#define MAX_LOG_LEN 1900
void skyeye_GetToken(char* channelId, char* token, char* terminalno, char* reserve1);




void GetUnitedTimeStr(time_t time, char* szTime)
{
	struct tm* tm = localtime(&time);
	sprintf(szTime, "%04d-%02d-%02dT%02d:%02d:%02d.000000000Z",
		tm->tm_year + 1900,
		tm->tm_mon + 1,
		tm->tm_mday,
		tm->tm_hour,
		tm->tm_min,
		tm->tm_sec
	);
}

int GetLocalIP(char* ip_str)
{
#ifdef _WIN32
	struct hostent* ent;
	char tmp[256] = "";
	int i;

	__try {
		ent = gethostbyname(tmp);
	}
	__except (EXCEPTION_EXECUTE_HANDLER) {
		strcpy(ip_str, "0.0.0.0");
		return -1;
	}

	if (ent) {
		for (i = 0; ent->h_addr_list[i]; ++i) {
			if (ent->h_addrtype == AF_INET) {
				struct in_addr* in = (struct in_addr*)ent->h_addr_list[i];
				char* p = inet_ntoa(*in);
				if (p[0] != '0') {
					strcpy(ip_str, p);
					return 0;
				}
			}
		}
	}
#else
	int sockfd = -1;
	struct ifconf ifconf;
	struct ifreq* ifreq = NULL;
	char strbuf[256] = { 0 };
	ifconf.ifc_len = 256;
	ifconf.ifc_buf = strbuf;
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) >= 0) {
		ioctl(sockfd, SIOCGIFCONF, &ifconf); //get all socket info
		ifreq = (struct ifreq*)ifconf.ifc_buf;
		for (int i = (ifconf.ifc_len / sizeof(struct ifreq)); i > 0; i--) {
			if (ifreq->ifr_flags == AF_INET) { //for ipv4
				char* strIP = inet_ntoa(((struct sockaddr_in*)&(ifreq->ifr_addr))->sin_addr);
				ifreq++;
				if (NULL != strIP) {
					if (NULL == strstr(strIP, "198.168.") && NULL == strstr(strIP, "127.0.0.1")) {
						strcpy(ip_str, strIP);
						close(sockfd);
						return 0;
					}
				}
			}
		}
		close(sockfd);
	}

#endif //_WIN32
	return -1;

}


std::string get_format_uuid()
{
	char strbuffer[64] = "";
	int uuidlen = 0;
	uuid4_init();
	uuid4_generate(strbuffer);
	return strbuffer;
}

class TokenManager {
private:
	std::string endpoint;
	std::string channelId;
	std::string tokenSecret;
	std::string terminalno;
	std::string installVersion;

	//need return channelId and token
	std::string token;

	//every 20 minites execute getToken task
	std::chrono::system_clock::time_point lastExecutionTime;
	std::chrono::minutes interval;


public:
	static TokenManager& getInstance()
	{
		static TokenManager cur;
		return cur;
	}
	void InitTokenManager(int t_expired_min, std::string t_endpoint, std::string t_channelId,
		std::string t_tokenSecret, std::string t_terminalno, std::string t_installVersion)
	{
		interval = std::chrono::minutes(t_expired_min);
		endpoint = t_endpoint + "/api/auth/v2/token";
		channelId = t_channelId;
		tokenSecret = t_tokenSecret;
		terminalno = t_terminalno;
		installVersion = t_installVersion;
		getToken();
	}

	std::string getTerminalNo()
	{
		return terminalno;
	}

	std::pair<std::string ,std::string> getToken()
	{
		auto execute_refreshToken = [this] {
			HttpClientRequestConfig config(HttpRequestMethod::POST, endpoint, NULL);
			HttpClientResponseResult result;


			Json::Value businessId;
			businessId["installVersion"] = installVersion;
			businessId["terminalNo"] = terminalno;
			Json::FastWriter writer;
			std::string businessId_str = writer.write(businessId);

			Json::Value root;
			root["channelId"] = channelId;
			root["clientSecret"] = tokenSecret;
			root["businessId"] = businessId_str;
			std::string root_str = writer.write(root);

			config.SetJsonBody(root_str);

			RestfulClient client = RestfulClient::getInstance();
			client.Do(&config, &result, NULL);
			if (result.ResponseOK()) {
				//解析返回字符串
				Json::Reader reader;
				Json::Value rootRet;
				if (!reader.parse(result.content, rootRet, false))
					return;

				token = rootRet["data"].asString();
				if (token.length() > 0)
					lastExecutionTime = std::chrono::system_clock::now();
			}
		};

		if (endpoint.length() == 0 && channelId.length() == 0 && endpoint.length() == 0 
			&& tokenSecret.length() == 0 && terminalno.length() == 0 && installVersion.length() == 0)
			return std::make_pair("", "");


		auto duration = std::chrono::duration_cast<std::chrono::minutes>(std::chrono::system_clock::now() - lastExecutionTime);
		if (duration >= interval)//already expired
		{
			execute_refreshToken();
			return std::make_pair(token.length() > 0 ? channelId : "", token.length() > 0 ? token : "");
		}
		else if (duration >= interval / 2)// pre update token
		{
			std::string oldToken = token;
			std::thread (execute_refreshToken).detach();
			return std::make_pair(oldToken.length() > 0 ? channelId : "", oldToken.length() > 0 ? oldToken : "");
		}
		else
			return std::make_pair(token.length() > 0 ? channelId : "", token.length() > 0 ? token : "");

	}
};

/*reference example
* 
{
	"_CMB_LOG_SPEC_VERSION": "2.0",
	"level": "DEBUG",
	"ts": "2024-09-03T15:09:50.000000000Z",
	"type": "BASETYPE",
	"serviceUnitId": "LR04.02@FrameworkLib_PRD_PRD",
	"log": {
		"content": {
			"CmptId": "LR04",
			"CmptName": "FrameworkLib",
			"LogFile": "SD",
			"EvenTime": "2024-09-03 15:09:50.414",
			"CostTime": 0,
			"VtmUuid": "1f595ef586bc427fa49ee5bf9842e110",
			"Version": "1.0",
			"DateTime": "2024-09-03 15:09:50.414",
			"ResultCode": "SUC0000",
			"LogCode": "",
			"API": "",
			"TipMsg": "",
			"BussID": "",
			"SourceType": "",
			"ResultMsg": "ReadConfigValue can not find value:site",
			"TraceID": "",
			"Item": "1",
			"EntityName": "mod_chromium",
			"LifeID": 4,
			"TimeSn": 125,
			"ServName": "7555980277",
			"TerminalNo": "7555980277",
			"SN": "7.5.1.1",
			"ClientIP": "192.168.56.1"
		}
	}
	
}
*/

void GetTimeStr(time_t time, char* szTime)
{
#if defined(_MSC_VER)
	LARGE_INTEGER liTime, liFreq;
	double dTime;
	struct tm* tm = localtime(&time);
	QueryPerformanceFrequency(&liFreq);
	QueryPerformanceCounter(&liTime);
	dTime = (double)liTime.QuadPart / (double)liFreq.QuadPart;

	sprintf(szTime, "%04d-%02d-%02d %02d:%02d:%02d.%03d",
		tm->tm_year + 1900,
		tm->tm_mon + 1,
		tm->tm_mday,
		tm->tm_hour,
		tm->tm_min,
		tm->tm_sec,
		(long)(dTime * 1000) % 1000
	);
#else
	struct timeval tv;
	struct tm* tm = localtime(&time);
	gettimeofday(&tv, NULL);
	sprintf(szTime, "%04d-%02d-%02d %02d:%02d:%02d.%03d",
		tm->tm_year + 1900,
		tm->tm_mon + 1,
		tm->tm_mday,
		tm->tm_hour,
		tm->tm_min,
		tm->tm_sec,
		tv.tv_usec / 1000
	);
#endif //_MSC_VER
}

Link_private::Link_private(LOG_LEVEL_E t_level, LOG_TYPE_E t_type)
	: Level(t_level), Type(t_type), BeginTime(0), EndTime(0), CostTime(0), ResultCode("SUC0000")
{
	TraceID = ResultMsg = LogCode = API = BussID = TipMsg = SourceType = recordTime = VtmCode = "";
	char nowTime[64] = { 0 };
	auto now = time(NULL);
	GetTimeStr(now, nowTime);
	recordTime = nowTime;
}

class skyeye_sender {
private:
	std::mutex m_mtx;
	std::list<Link_private> m_msgArr;
	int m_TimeSn;
	std::chrono::system_clock::time_point m_beginTime;
	std::string convertLinkPrivateToStr(const Link_private& cur)
	{
		static char local_ip_str[64] = "0.0.0.0";
		static long ipInit = 0;
		//get ip every 1000 times
		if (ipInit % 1000 == 0)
			GetLocalIP(local_ip_str);
		ipInit++;


		Json::Value root;
		root["_CMB_LOG_SPEC_VERSION"] = "2.0";
		root["level"] = cur.get_baseLogType();
		root["ts"] = cur.recordTime;
		root["type"] = "BASETYPE";
		root["serviceUnitId"] = skyeye_logger::getDefaultLogger().m_constParam.m_serviceUnitId;
		Json::Value root_log;
		root_log["CmptId"] = skyeye_logger::getDefaultLogger().m_constParam.m_cmptId;
		root_log["CmptName"] = skyeye_logger::getDefaultLogger().m_constParam.m_cmptName;
		root_log["LogFile"] = cur.get_LogFile();
		root_log["EvenTime"] = cur.recordTime;
		root_log["CostTime"] = cur.CostTime;
		root_log["VtmUuid"] = get_format_uuid();
		root_log["Version"] = "1.0";
		root_log["DateTime"] = cur.recordTime;
		root_log["ResultCode"] = cur.ResultCode.length() > 0 ? cur.ResultCode : "";
		root_log["LogCode"] = cur.LogCode;
		root_log["API"] = cur.API;
		root_log["TipMsg"] = cur.TipMsg;
		root_log["BussID"] = cur.BussID;
		root_log["SourceType"] = cur.SourceType;
		root_log["ResultMsg"] = cur.ResultMsg;
		root_log["TraceID"] = cur.TraceID;
		root_log["Item"] = skyeye_logger::getDefaultLogger().m_constParam.m_item;
		root_log["EntityName"] = skyeye_logger::getDefaultLogger().m_constParam.m_entityName;
		auto currentTime = std::chrono::system_clock::now();
		auto elapsedTime = std::chrono::duration_cast<std::chrono::seconds>(currentTime - m_beginTime);
		root_log["LifeID"] = elapsedTime.count();
		root_log["TimeSn"] = ++m_TimeSn;
		root_log["ServName"] = skyeye_logger::getDefaultLogger().m_constParam.m_terminalNo;
		root_log["TerminalNo"] = skyeye_logger::getDefaultLogger().m_constParam.m_terminalNo;
		root_log["SN"] = skyeye_logger::getDefaultLogger().m_constParam.m_version;
		root_log["ClientIP"] = local_ip_str;
		Json::Value content_log;
		content_log["content"] = root_log;
		root["log"] = content_log;

		Json::FastWriter writer;
		std::string dst = writer.write(root);
		return dst;
	}
public:
	static skyeye_sender& getInstance()
	{
		static skyeye_sender cur;
		return cur;
	}
	void LogToSender(Link_private* msg)
	{
		
		m_mtx.lock();
		m_msgArr.push_back(*msg);
		m_mtx.unlock();
		
	}
	void InitSender(std::string t_endpoint, std::string t_topic)
	{
		
		auto skyeye_sender = [this](std::string t_endpoint, std::string t_topic) {
			while (true)
			{
				if (m_msgArr.empty())
					std::this_thread::sleep_for(std::chrono::seconds(1));//every 1 seconds
				std::vector<Link_private> sendArr;
				m_mtx.lock();
				//max send 12 logs
				for (int i = 0; i < 12; i++)
				{
					if (m_msgArr.size() == 0)
						break;

					sendArr.emplace_back(m_msgArr.front());
					m_msgArr.pop_front();
				}
				m_mtx.unlock();

				if (sendArr.size() == 0)
					continue; //no need to send

				//generate send str
				Json::Value root;
				Json::Value arraylist;//消息列表
				Json::FastWriter fw;//写入对象
				for (int i = 0; i < sendArr.size(); i++)
				{
					arraylist[i] = convertLinkPrivateToStr(sendArr[i]);
				}
				root["message_list"] = arraylist;
				root["topic"] = t_topic;
				auto sendStr = fw.write(root);


				//send
				HttpClientResponseResult result;
				HttpClientRequestConfig config(HttpRequestMethod::POST, t_endpoint, skyeye_GetToken);
				config.SetTimeout(60);

				config.SetJsonBody(sendStr.c_str());

				RestfulClient client = RestfulClient::getInstance();
				config.PreDo();
				client.Do(&config, &result, NULL);
				if (result.ResponseOK()) {
					struct CommResponse
					{
						bool success;
						std::string errorCode;
						std::string returnCode;
						std::string errorMsg;
						std::string message;

						JSONCONVERT2OBJECT_MEMEBER_REGISTER(success, errorCode, returnCode, errorMsg, message)
							JSONCONVERT2OBJECT_MEMEBER_RENAME_REGISTER("success", "code", "return_code", "error_msg", "message")
					} responseIns;

					Json::Value rawRoot;
					if (GetJsonRootObject(rawRoot, result.content) && Json2Object(responseIns, rawRoot)) {
						if (!responseIns.success)
						{
							if (responseIns.errorCode.find("RTI1002") != -1)
							{
								m_mtx.lock();

								for (auto it : sendArr)
									m_msgArr.emplace_back(it);
								m_mtx.unlock();
								std::this_thread::sleep_for(std::chrono::seconds(30));//upload logs failed
							}
						}
					}
				}
				else
				{
					m_mtx.lock();

					for (auto it : sendArr)
						m_msgArr.emplace_back(it);
					m_mtx.unlock();
				}
			}
			
		};
		
		std::thread(skyeye_sender, t_endpoint, t_topic).detach();
	}

	skyeye_sender()
		: m_TimeSn(0)
	{
	};



};

#define MAX_TOKEN_LEN 256
void skyeye_GetToken(char* channelId, char* token, char* terminalno, char* reserve1)
{
	auto tokenInfo = TokenManager::getInstance().getToken();
	auto terminalnoInfo = TokenManager::getInstance().getTerminalNo();

	snprintf(channelId, MAX_TOKEN_LEN, "%s", tokenInfo.first.c_str());
	snprintf(token, MAX_TOKEN_LEN, "%s", tokenInfo.second.c_str());
	snprintf(terminalno, MAX_TOKEN_LEN, "%s", terminalnoInfo.c_str());

}

skyeye_logger& skyeye_logger::getDefaultLogger()
{
	// TODO: 在此处插入 return 语句
	static skyeye_logger cur;
	if (cur.m_msg == nullptr)
		cur.m_msg = new Link_private(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM);
	else
	{
		delete cur.m_msg;
		cur.m_msg = new Link_private(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM);
	}
	return cur;
}

skyeye_logger& skyeye_logger::setLogLevel(LOG_LEVEL_E t_level)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->Level = t_level;
	return *this;
}

skyeye_logger& skyeye_logger::setLogType(LOG_TYPE_E t_type)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->Type = t_type;
	return *this;
}

skyeye_logger& skyeye_logger::setResultCode(std::string t_ResultCode)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->ResultCode = t_ResultCode;
	return *this;
}

skyeye_logger& skyeye_logger::setTraceID(std::string t_TraceID)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->TraceID = t_TraceID;
	return *this;
}

skyeye_logger& skyeye_logger::setResultMsg(std::string t_ResultMsg)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->ResultMsg = t_ResultMsg;
	return *this;
}

skyeye_logger& skyeye_logger::setLogCode(std::string t_LogCode)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->LogCode = t_LogCode;
	return *this;
}

skyeye_logger& skyeye_logger::setAPI(std::string t_API)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->API = t_API;
	return *this;
}

skyeye_logger& skyeye_logger::setBussID(std::string t_BussID)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->BussID = t_BussID;
	return *this;
}

skyeye_logger& skyeye_logger::setTipMsg(std::string t_TipMsg)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->TipMsg = t_TipMsg;
	return *this;
}

skyeye_logger& skyeye_logger::setSourceType(std::string t_SourceType)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->SourceType = t_SourceType;
	return *this;
}

skyeye_logger& skyeye_logger::setBeginTime(long t_BeginTime)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->BeginTime = t_BeginTime;
	return *this;
}

skyeye_logger& skyeye_logger::setEndTime(long t_EndTime)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->EndTime = t_EndTime;
	return *this;
}

skyeye_logger& skyeye_logger::setCostTime(long t_costTime)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->CostTime = t_costTime;
	return *this;
}

skyeye_logger& skyeye_logger::setVtmCode(std::string t_VtmCode)
{
	// TODO: 在此处插入 return 语句
	if (m_msg != nullptr)
		m_msg->VtmCode = t_VtmCode;
	return *this;
}

void skyeye_logger::operator()(LOG_LEVEL_E t_level, const char* str, ...)
{
	if (m_msg != nullptr)
	{
		if (str == nullptr)
			return;

		va_list arg;
		va_start(arg, str);

		int n = _vscprintf(str, arg) + 1;
		if (n > MAX_LOG_LEN) {
			n = MAX_LOG_LEN;
		}

		std::vector<char> buf(n + 1, '\0');
		vsnprintf(&buf[0], n, str, arg);
		va_end(arg);



		m_msg->Level = t_level;
		m_msg->ResultMsg = &buf[0];

		skyeye_sender::getInstance().LogToSender(m_msg);

		delete m_msg;
		m_msg = nullptr;
	}


}

void CreateDefaultLogger(std::string logEndpoint, std::string logTopic,std::string tokenEndpoint, std::string channelId, std::string tokenSecret, Link_const constParam)
{
	skyeye_logger::getDefaultLogger().m_constParam = constParam;
	TokenManager::getInstance().InitTokenManager(30, tokenEndpoint, channelId, tokenSecret, constParam.m_terminalNo, constParam.m_version);
	skyeye_sender::getInstance().InitSender(logEndpoint, logTopic);
}

void CreateDefaultLogger(std::string terminalno, std::string version, std::string entityName, std::string itemId)
{
	Link_const constParam;
	constParam.m_entityName = entityName;
	constParam.m_item = itemId;
	constParam.m_terminalNo = terminalno;
	constParam.m_version = version;
	constParam.m_cmptId = SpDefine::cmptId;
	constParam.m_cmptName = SpDefine::CmptName;
	constParam.m_serviceUnitId = SpDefine::serviceUnitId;
	constParam.m_deployUnitId = SpDefine::deployUnitId;
	//std::this_thread::sleep_for(std::chrono::seconds(10));//every 30 seconds
	skyeye_logger::getDefaultLogger().m_constParam = constParam;
	TokenManager::getInstance().InitTokenManager(30, SpDefine::CommonLaunchUrl, SpDefine::channelId, SpDefine::tokenSecret, constParam.m_terminalNo, constParam.m_version);
	//skyeye_sender::getInstance();
	std::string endpoint = SpDefine::endpoint_env;
	std::string topic = SpDefine::topicSys;
	skyeye_sender::getInstance().InitSender(endpoint, topic);

}

skyeye_logger& GetDefaultLogger()
{
	return skyeye_logger::getDefaultLogger();
}