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
#include <SpBase.h>

#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] {
			std::string srcBusId = "LR0402getToken";
			std::string srcTraceId = uuid4_generate(32);
			std::string srcSpanId = uuid4_generate(16);
			std::string srcParentSpanId = "0";
			std::string srcTimestamp = std::to_string(std::chrono::system_clock::now().time_since_epoch().count());

			HttpClientTraceLink headLink;
			memset(&headLink, 0, sizeof(headLink));
			strncpy(headLink.X_B3_BusinessId, srcBusId.c_str(), 32);
			strncpy(headLink.X_B3_TraceId, srcTraceId.c_str(), 32);
			strncpy(headLink.X_B3_SpanId, srcSpanId.c_str(), 16);
			strncpy(headLink.X_B3_ParentSpanId, srcParentSpanId.c_str(), 16);
			strncpy(headLink.X_B3_Timestamp, srcTimestamp.c_str(), 16);

			beidou_logger::getDefaultLogger(headLink, "guardian_getToken")();
			HttpClientTraceLink nextLink;
			memset(&nextLink, 0, sizeof(nextLink));
			std::string nextSpanId = uuid4_generate(16);
			strncpy(nextLink.X_B3_BusinessId, srcBusId.c_str(), 32);
			strncpy(nextLink.X_B3_TraceId, srcTraceId.c_str(), 32);
			strncpy(nextLink.X_B3_SpanId, nextSpanId.c_str(), 16);
			strncpy(nextLink.X_B3_ParentSpanId, srcSpanId.c_str(), 16);
			strncpy(nextLink.X_B3_Timestamp, srcTimestamp.c_str(), 16);

			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, &nextLink);
			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;
	std::list<Beidou_private> m_beidouMsgArr;
	int m_TimeSn;
	std::chrono::system_clock::time_point m_beginTime;
	std::string convertBeidouPrivateToStr(const Beidou_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++;

		const char* t_header = "[[tracing]]";
		Json::Value root;
		root["businessId"] = cur.BussID;
		root["traceId"] = cur.TraceID;
		root["spanId"] = cur.SpanId;
		root["parentSpanId"] = cur.ParentSpanId;
		root["timestamp"] = cur.t_timeStamp;
		root["deployUnitId"] = skyeye_logger::getDefaultLogger().m_constParam.m_deployUnitId;
		root["serviceUnitId"] = skyeye_logger::getDefaultLogger().m_constParam.m_serviceUnitId;
		root["host"] = cur.Host;
		root["api"] = cur.Api;
		root["responseTime"] = cur.ResponseTime;
		root["returnCode"] = cur.ReturnCode;

		root["callStack"] = Json::arrayValue;
		root["tags"]["TerminalNo"] = skyeye_logger::getDefaultLogger().m_constParam.m_terminalNo;
		root["dbStack"] = Json::arrayValue; // 空数组

		Json::FastWriter writer;
		std::string dst = t_header + writer.write(root) + t_header;
		return dst;
	}


	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 LogToBeidouSender(Beidou_private* msg)
	{
		m_mtx.lock();
		m_beidouMsgArr.push_back(*msg);
		m_mtx.unlock();
	}


	void InitSender(std::string t_endpoint, std::string t_topic, std::string t_beidou_topic)
	{
		
		auto skyeye_sender = [this](std::string t_endpoint, std::string t_topic, std::string t_beidou_topic) {
			auto beidou_send = [&]{
				std::vector<Beidou_private> sendArr;
				m_mtx.lock();
				//max send 12 logs
				for (int i = 0; i < 12; i++)
				{
					if (m_beidouMsgArr.size() == 0)
						break;
					sendArr.emplace_back(m_beidouMsgArr.front());
					m_beidouMsgArr.pop_front();
				}
				m_mtx.unlock();

				if (sendArr.size() == 0)
					return; //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] = convertBeidouPrivateToStr(sendArr[i]);
				root["message_list"] = arraylist;
				root["topic"] = t_beidou_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_beidouMsgArr.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_beidouMsgArr.emplace_back(it);
					m_mtx.unlock();
				}
			};



			auto skyeye_send = [&]{
				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)
					return; //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();
				}
			};


			while (true)
			{
				if (m_msgArr.empty() && m_beidouMsgArr.empty())
				{
					std::this_thread::sleep_for(std::chrono::seconds(1));//every 1 seconds
					continue;
				}
				if (!m_msgArr.empty())
					skyeye_send();
				if (!m_beidouMsgArr.empty())
					beidou_send();
			}
			
		};
		
		std::thread(skyeye_sender, t_endpoint, t_topic, t_beidou_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);
	std::string beidouTopic = SpDefine::topicBeidou;
	skyeye_sender::getInstance().InitSender(logEndpoint, logTopic, beidouTopic);
}

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;
	std::string beidouTopic = SpDefine::topicBeidou;

	skyeye_sender::getInstance().InitSender(endpoint, topic, beidouTopic);

}

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


beidou_logger& beidou_logger::getDefaultLogger(const HttpClientTraceLink& t_context, const std::string& t_Api)
{
	// TODO: 在此处插入 return 语句
	static beidou_logger cur;
	if (cur.m_msg == nullptr)
		cur.m_msg = new Beidou_private(t_context, t_Api);
	else
	{
		delete cur.m_msg;
		cur.m_msg = new Beidou_private(t_context, t_Api);
	}
	return cur;
}

beidou_logger& beidou_logger::setHost(std::string t_host) {
    m_msg->Host = t_host;
    return *this;
}

beidou_logger& beidou_logger::setReturnCode(std::string t_ReturnCode) {
    m_msg->ReturnCode = t_ReturnCode;
    return *this;
}

beidou_logger& beidou_logger::setResponseTime(std::string t_ResponseTime) {
    m_msg->ResponseTime = t_ResponseTime;
    return *this;
}



beidou_logger& beidou_logger::set_deployUnitId(std::string t_deployUnitId) {
    m_msg->deployUnitId = t_deployUnitId;
    return *this;
}
beidou_logger& beidou_logger::set_serviceUnitId(std::string t_serviceUnitId) {
    m_msg->serviceUnitId = t_serviceUnitId;
    return *this;
}

void beidou_logger::operator () () {
	if(m_msg)
	{
		skyeye_sender::getInstance().LogToBeidouSender(m_msg);

		delete m_msg;
		m_msg = nullptr;
	}	
}