myvtm/Framework/RvcLogSdk/log_producer_client.cpp

#include "log_producer_client.h"
#include "log_producer_manager.h"
#include "inner_log.h"
#include "log_api.h"
#include <stdarg.h>
#include <string.h>
#include "log_persistent_manager.h"
#include "log_multi_thread.h"
#include "baseFun.h"

static uint32_t s_init_flag = 0;
static log_producer_result s_last_result = 0;
static int disable_log_sdk = 0;

typedef struct _producer_client_private {

    log_producer_manager* producer_manager;
    log_producer_config* producer_config;
    log_persistent_manager* persistent_manager;

}producer_client_private;


log_producer_result log_producer_env_init()
{
    // if already init, just return s_last_result
    if (s_init_flag == 1)
    {
        return s_last_result;
    }
    s_init_flag = 1;

    if (0 != sls_log_init(0))
    {
        s_last_result = LOG_PRODUCER_INVALID;
    }
    else
    {
        s_last_result = LOG_PRODUCER_OK;
    }
    return s_last_result;
}

void log_producer_env_destroy()
{
    if (s_init_flag == 0)
    {
        return;
    }
    s_init_flag = 0;
    sls_log_destroy();
}


log_producer_client* create_log_producer_client(log_producer_config* config, on_log_producer_send_done_function send_done_function, void* user_param)
{
    int log_ret;
    int log_level;
    log_producer_client* producer_client;
    producer_client_private* client_private;
    if (config->persistentFilePath == NULL || config->skyeyeEntityName == NULL) {
        return NULL;
    }
    //log_level = LM_DEBUG;
    log_level = !!(config->debugMode) ? LM_DEBUG : LM_OFF;
    log_ret = RvcLog_init(config->persistentFilePath, config->skyeyeEntityName, log_level, 1);//写本地日志
    if (log_ret) {
        return NULL;
    }
    if (!log_producer_config_is_valid(config))
    {
        return NULL;
    }
    producer_client = (log_producer_client*)malloc(sizeof(log_producer_client));
    if (disable_log_sdk) {
        return producer_client;
    }
    client_private = (producer_client_private*)malloc(sizeof(producer_client_private));
    producer_client->private_data = client_private;
    client_private->producer_config = config;
    //nor:flush线程，用于传送数据到spshell，shell:flush,send * n, read, write
    client_private->producer_manager = create_log_producer_manager(config);
    client_private->producer_manager->send_done_function = send_done_function;
    client_private->producer_manager->user_param = user_param;
    client_private->producer_manager->start_time = time(NULL);

    client_private->persistent_manager = create_log_persistent_manager(config);//就只创建了个db
    if (client_private->persistent_manager != NULL) {
        client_private->producer_manager->uuid_user_param = client_private->persistent_manager;
        client_private->producer_manager->uuid_send_done_function = on_log_persistent_manager_send_done_uuid;
        client_private->producer_manager->persistent_manager = client_private->persistent_manager;
    }

    aos_debug_log((LB, "create producer client success"));
    producer_client->valid_flag = 1;

    return producer_client;
}


void destroy_log_producer_client(log_producer_client* client)
{
    producer_client_private* client_private;
	if (client == NULL) {
		return;
	}
    if (disable_log_sdk) {
        free(client);
        RvcLog_destroy();
        return;
    }

    client->valid_flag = 0;
    client_private = (producer_client_private*)client->private_data;
    if (client_private != NULL) {
		destroy_log_producer_manager(client_private->producer_manager);
		destroy_log_persistent_manager(client_private->persistent_manager);
        //WARNING: the produce above would let the process lost at UOS platform.

		destroy_log_producer_config(client_private->producer_config);
		free(client_private);
        client->private_data = NULL;
    }
    free(client);
	aos_debug_log((LB, "destroy producer client"));
	RvcLog_destroy();
}

log_producer_result log_producer_client_add_log(log_producer_client* client,
    log_item* log, int flush, long record_time)
{
    int rst;
    int i = 0, j = 0;
    log_producer_manager* manager;
    if (client == NULL || !client->valid_flag)
    {
        aos_error_log((LB, "log producer client add log failed for null"));
        return LOG_PRODUCER_INVALID;
    }
    if (disable_log_sdk) {
        return LOG_PRODUCER_OK;
    }
    manager = ((producer_client_private*)client->private_data)->producer_manager;
    CS_ENTER(manager->lock);
    manager->pack_index++;
    CS_LEAVE(manager->lock);

    //日志放入内存缓存，再发送
    rst = log_producer_manager_add_log(manager, log, flush, record_time);
    //aos_debug_log((LB, "log producer client add log rst %d", rst));
    
    RvcLogSdkManager::getInstance().m_logFlush_num++;
    return rst;
}

log_producer_result log_producer_client_add_beidou_log(log_producer_client* client,
    beidou_log_item* log, int flush) {

    int rst;
    int i = 0, j = 0;
    log_producer_manager* manager;
    if (client == NULL || !client->valid_flag)
    {
        aos_error_log((LB, "log producer client add beidou log failed for null"));
        return LOG_PRODUCER_INVALID;
    }
    if (disable_log_sdk) {
        return LOG_PRODUCER_OK;
    }
    manager = ((producer_client_private*)client->private_data)->producer_manager;
    CS_ENTER(manager->lock);
    manager->pack_index++;
    CS_LEAVE(manager->lock);

    //日志放入内存缓存，再发送
    rst = log_producer_manager_add_beidou_log(manager, log, flush);
    //aos_debug_log((LB, "log producer client add beidou log rst %d", rst));

    return rst;
}

void log_producer_set_testLogMode()
{
    RvcLogSdkManager::getInstance().m_testLogMode = true;
}

int log_producer_sendTestLog_loki(const char* app, const char* env, const char* body)
{
    return RvcLogSdkManager::getInstance().SendTestLog_loki(app, env, body);
}