#include "fieldstat/fieldstat_easy.h"
#include "field_stat2.h"
#include "fieldstat.h"

#include "sapp_declaration.h"
#include "sapp_pkt_stat.h"

void sapp_fs2_update_count(int field_index, unsigned  long long value)
{
	if(sapp_global_val->individual_fixed.fs2_runtime.fs_metric_handle != NULL){
		FS_operate(sapp_global_val->individual_fixed.fs2_runtime.fs_metric_handle, 
					sapp_global_val->individual_fixed.fs2_runtime.fs_id_count_array[field_index], 
					0, FS_OP_SET,  (long long)value);
	}
}

void sapp_fs2_update_length(int field_index, unsigned  long long value)
{
	if(sapp_global_val->individual_fixed.fs2_runtime.fs_metric_handle != NULL){
		FS_operate(sapp_global_val->individual_fixed.fs2_runtime.fs_metric_handle, 
					sapp_global_val->individual_fixed.fs2_runtime.fs_id_length_array[field_index],  
					0, FS_OP_SET,  (long long)value);
	}
}

void sapp_fs2_set_work_percent(int thead_seq, long long work_percent)
{
    if(sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle != NULL){
        FS_operate(sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle, 
        		   sapp_global_val->individual_fixed.fs2_runtime.fs_work_percent_id_array[thead_seq], 
        		   0, FS_OP_SET, work_percent);
    }
}

void sapp_fs2_set_latency(int thead_seq, long long time_cost)
{
    if(sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle != NULL){
        FS_operate(sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle, 
        		   sapp_global_val->individual_fixed.fs2_runtime.fs_latency_id_array[thead_seq], 
        		   0, FS_OP_SET, time_cost);
    }
}



void sapp_fs2_set_plug_entry_latency(int entry_id, long long time_cost)
{
	if(unlikely(entry_id < 0 || entry_id >= SAPP_MAX_PLUG_ENTRY_NUM)){
		return;
	}
    if(sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle != NULL){
        FS_operate(sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle, 
        		   sapp_global_val->individual_fixed.fs2_runtime.fs_latency_plug_entrg_id_array[entry_id], 
        		   0, FS_OP_SET, time_cost);
    }
}

/*
	ģ�������������ʱ, ����ÿ����������һ��FS_operate(),
	��sapp timer�߳�ÿ��һ��ʱ�����sapp_fuzzy_latency_update(), ����filed_stat2����.
*/
extern "C" void sapp_fs2_fuzzy_latency_update_per_thread(int thead_seq, long long time_cost)
{
	sapp_fuzzy_latency_stat_t *this_thread_stat = &sapp_global_val->mthread_volatile[thead_seq]->fuzzy_pkt_latency_stat_per_thread;

	if(time_cost < this_thread_stat->min_time_cost){
		this_thread_stat->min_time_cost = time_cost;
	}

	if(time_cost > this_thread_stat->max_time_cost){
		this_thread_stat->max_time_cost = time_cost;
	}
	
	this_thread_stat->time_cost_sum += time_cost;
	this_thread_stat->stat_count++;
}

extern "C" void sapp_fs2_fuzzy_latency_update_per_entry(int thead_seq, int entry_id, long long time_cost)
{
	sapp_fuzzy_latency_stat_t *this_thread_stat;
	if(unlikely(entry_id < 0 || entry_id >= SAPP_MAX_PLUG_ENTRY_NUM)){
		return;
	}	

	this_thread_stat = &sapp_global_val->mthread_volatile[thead_seq]->fuzzy_pkt_latency_stat_per_entry_per_thread[entry_id];

	if(time_cost < this_thread_stat->min_time_cost){
		this_thread_stat->min_time_cost = time_cost;
	}

	if(time_cost > this_thread_stat->max_time_cost){
		this_thread_stat->max_time_cost = time_cost;
	}
	
	this_thread_stat->time_cost_sum += time_cost;
	this_thread_stat->stat_count++;

}


/*
	��sapp timer�����̵߳���, ÿ��һ��ʱ��, �����۵İ�������ʱ����ˢ�¸�field_stat2.
*/
void sapp_fuzzy_latency_update(void)
{
	int tid, entry_id, this_stat_count;
	long long min_latency, max_latency;
	double avg_latency;
	sapp_fuzzy_latency_stat_t *this_thread_stat, *this_entry_stat;
	
	for(tid = 0; tid < g_packet_io_thread_num; tid++){
		this_thread_stat = &sapp_global_val->mthread_volatile[tid]->fuzzy_pkt_latency_stat_per_thread;
		avg_latency = (double)this_thread_stat->time_cost_sum/(double)this_thread_stat->stat_count;
		min_latency = this_thread_stat->min_time_cost;
		max_latency = this_thread_stat->max_time_cost;
		this_stat_count = this_thread_stat->stat_count;

		if(this_stat_count > 0){
			memset(this_thread_stat, 0, sizeof(sapp_fuzzy_latency_stat_t));
			this_thread_stat->min_time_cost = 999999999; /* Ҫ��¼��Сֵ, ��ʼ��Ҫ������ֵ */

			/* ÿ�θ�������ֵ, ���,��С��ƽ��ֵ */
			sapp_fs2_set_latency(tid, min_latency);
			sapp_fs2_set_latency(tid, max_latency);
			sapp_fs2_set_latency(tid, (long long)avg_latency);
		}
		
		for(entry_id = 1; entry_id < g_plug_global_entry_index; entry_id++){
			this_entry_stat = &sapp_global_val->mthread_volatile[tid]->fuzzy_pkt_latency_stat_per_entry_per_thread[entry_id];
			avg_latency = (double)this_entry_stat->time_cost_sum/(double)this_entry_stat->stat_count;
			min_latency = this_entry_stat->min_time_cost;
			max_latency = this_entry_stat->max_time_cost;
			this_stat_count = this_entry_stat->stat_count;
			if(this_stat_count > 0){
				memset(this_entry_stat, 0, sizeof(sapp_fuzzy_latency_stat_t));
				this_entry_stat->min_time_cost = 999999999; /* Ҫ��¼��Сֵ, ��ʼ��Ҫ������ֵ */
				
				sapp_fs2_set_latency(tid, min_latency);
				sapp_fs2_set_latency(tid, max_latency);
				sapp_fs2_set_plug_entry_latency(entry_id, (long long)avg_latency);
			}
		}
	}
}

static int sapp_process_latency_metric_init(sapp_global_t *global_paramters)
{
	void *fs2_handle=NULL;
	int fs2_opt;
	sapp_gval_individual_fixed_fs2_t *p_fs2_rt = &global_paramters->individual_fixed.fs2_runtime;
	if(strlen(global_paramters->config.profiling.process_latency_local_file) == 0)
	{
			return -1;
	}
	p_fs2_rt->fs_process_lantency_handle = FS_create_handle();
	if (NULL == p_fs2_rt->fs_process_lantency_handle)
	{
			sapp_log(RLOG_LV_FATAL, 30, 30, "FS_create_handle() error: %s!\n", strerror(errno));
			return -1;
	}
	fs2_handle = p_fs2_rt->fs_process_lantency_handle;
	FS_set_para(fs2_handle, STAT_CYCLE, &global_paramters->config.profiling.process_latency_refresh_interval_s, sizeof(int));

	fs2_opt = 1; /* 1:Rewrite ,2: Append.  */
	FS_set_para(fs2_handle, PRINT_MODE, &fs2_opt, sizeof(int));

	fs2_opt = 1;
	FS_set_para(fs2_handle, PRINT_TRIGGER, &fs2_opt, sizeof(int));

	fs2_opt = 1;
    FS_set_para(fs2_handle, NOT_SEND_METRIC_TO_SERVER, &fs2_opt, sizeof(int));	
	FS_set_para(fs2_handle, OUTPUT_DEVICE, ABBR_PROCESS_LATENTCY_DATA_FILE, strlen(ABBR_PROCESS_LATENTCY_DATA_FILE) + 1);

	for (int i = 0; i < g_packet_io_thread_num; i++)
	{
			char histogram_name[16];
			sprintf(histogram_name, "TD_ns(tid_%d)", i);
			p_fs2_rt->fs_latency_id_array[i] = FS_register_histogram(fs2_handle,	 // Field Stat���
																	 FS_CALC_SPEED,	 // ����ۼ�ֵ��˲ʱֵ
																	 histogram_name, // ͳ�������ƣ��ַ���
																	 1,				 // ��׷�ٵ���Сֵ
																	 1000000,		 // ��׷�ٵ����ֵ
																	 2);			 // ���ȣ���С�����λ����Χ1~4
			FS_set_para(fs2_handle, NOT_SEND_METRIC_TO_SERVER, &p_fs2_rt->fs_latency_id_array[i], sizeof(int));
	}

	/* 0������sapp���ò��, index��1��ʼ */
	for (int i = 1; i < g_plug_global_entry_index; i++)
	{
			p_fs2_rt->fs_latency_plug_entrg_id_array[i] = FS_register_histogram(p_fs2_rt->fs_metric_handle,				// Field Stat���
																				FS_CALC_SPEED,							// ����ۼ�ֵ��˲ʱֵ
																				g_plug_global_entry[i].plug_entry_name, // ͳ�������ƣ��ַ���
																				1,										// ��׷�ٵ���Сֵ
																				1000000,								// ��׷�ٵ����ֵ
																				2);										// ���ȣ���С�����λ����Χ1~4
			if (p_fs2_rt->fs_latency_plug_entrg_id_array[i] < 0)
			{
			sapp_runtime_log(RLOG_LV_FATAL, "FS_register_histogram() error, plug name:%s", g_plug_global_entry[i].plug_entry_name);
			return -1;
			}
	}

	for (int i = 0; i < g_packet_io_thread_num; i++)
	{
		char histogram_name[16];
		sprintf(histogram_name, "Work(tid_%d)", i);
		p_fs2_rt->fs_work_percent_id_array[i] = FS_register_histogram(fs2_handle,	 // Field Stat���
																 FS_CALC_SPEED,	 // ����ۼ�ֵ��˲ʱֵ
																 histogram_name, // ͳ�������ƣ��ַ���
																 1,				 // ��׷�ٵ���Сֵ
																 100,		 // ��׷�ٵ����ֵ
																 1);			 // ���ȣ���С�����λ����Χ1~4
		FS_set_para(fs2_handle, NOT_SEND_METRIC_TO_SERVER, &p_fs2_rt->fs_work_percent_id_array[i], sizeof(int));
	}
	return 0;
}

/************************ C++ compiler **************************************/
static int sapp_fs2_init(sapp_global_t *global_paramters)
{
	void *fs2_handle=NULL;
	int fs2_opt;
	sapp_gval_individual_fixed_fs2_t *p_fs2_rt = &global_paramters->individual_fixed.fs2_runtime;
	sapp_config_profiling_metric_t *p_fs2_para = &global_paramters->config.profiling.fs2;
	int fs2_local_enabled = 0;
	int fs2_prometheus_enabled = 0;

	if(strlen(p_fs2_para->local_file) > 0)
	{
		fs2_local_enabled = 1;
	}
	if(strlen(p_fs2_para->prometheus_service_uri) > 0 && p_fs2_para->prometheus_service_port > 0)
	{
		fs2_prometheus_enabled = 1;
	}	

	p_fs2_rt->fs_metric_handle = FS_create_handle();
	if(NULL == p_fs2_rt->fs_metric_handle){
		sapp_log(RLOG_LV_FATAL, 30, 30, "FS_create_handle() error: %s!\n", strerror(errno));
		return -1;
	}
	fs2_handle = p_fs2_rt->fs_metric_handle;
	if(fs2_prometheus_enabled){
		FS_library_set_prometheus_port((unsigned short)p_fs2_para->prometheus_service_port);
		FS_library_set_prometheus_url_path(p_fs2_para->prometheus_service_uri);
		if(FS_library_init() < 0){
			sapp_log(RLOG_LV_FATAL, 30, 30, "FS_library_init() error, port:%d, url:%s\n", 
					p_fs2_para->prometheus_service_port,
					p_fs2_para->prometheus_service_uri);
			return -1;			
		}
		fs2_opt = 1;
		FS_set_para(fs2_handle, OUTPUT_PROMETHEUS, &fs2_opt, sizeof(int));
	}

	FS_set_para(fs2_handle, STAT_CYCLE, &p_fs2_para->refresh_interval_s, sizeof(int));

	fs2_opt = 1; /* 1:Rewrite ,2: Append.  */
	FS_set_para(fs2_handle, PRINT_MODE, &fs2_opt, sizeof(int));

	fs2_opt = 1;
	FS_set_para(fs2_handle, PRINT_TRIGGER, &fs2_opt, sizeof(int));

	fs2_opt = 1;
    FS_set_para(fs2_handle, NOT_SEND_METRIC_TO_SERVER, &fs2_opt, sizeof(int));

	if (fs2_local_enabled)
	{
		FS_set_para(fs2_handle, OUTPUT_DEVICE, ABBR_FS2_LOG_DATA_FILE, strlen(ABBR_FS2_LOG_DATA_FILE) + 1);
	}
	else
	{
		sapp_log(RLOG_LV_INFO, 10, 10, "profiling.log.local.enabled is 0, not save local stat log file.\n");
		FS_set_para(fs2_handle, OUTPUT_DEVICE, "/dev/null", strlen("/dev/null") + 1);
	}
	FS_set_para(fs2_handle, APP_NAME, p_fs2_para->app_name, strlen(p_fs2_para->app_name)+1);


	p_fs2_rt->fs_id_count_array[SAPP_STAT_RCV_LINE] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Line_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_RCV_LINE] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Line_Bit");
	
	p_fs2_rt->fs_id_count_array[SAPP_STAT_RCV_ETHERNET] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Eth_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_RCV_ETHERNET] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Eth_Bit");

	if((DEPLOYMENT_MODE_INLINE == sapp_global_val->config.packet_io.deployment_mode_bin)
	 || (DEPLOYMENT_MODE_TRANSPARENT == sapp_global_val->config.packet_io.deployment_mode_bin)){
		p_fs2_rt->fs_id_count_array[SAPP_STAT_ETH_INBOUND] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Pkt_Inbound");
		p_fs2_rt->fs_id_length_array[SAPP_STAT_ETH_INBOUND] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Bit_Inbound");	 
		p_fs2_rt->fs_id_count_array[SAPP_STAT_ETH_OUTBOUND] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Pkt_Outbound");
		p_fs2_rt->fs_id_length_array[SAPP_STAT_ETH_OUTBOUND] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Bit_Outbound");			
	}

	p_fs2_rt->fs_id_count_array[SAPP_STAT_RCV_UNKNOWN] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Unknown_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_RCV_UNKNOWN] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Unknown_Bit");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_SND_ERROR] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Snd_Err_Pkt");
	//pfs_para->fs_id_length_array[SAPP_STAT_SND_ERROR] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Snd_Err_Bit");	 

	p_fs2_rt->fs_id_count_array[SAPP_STAT_RCV_IPV4] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Ipv4_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_RCV_IPV4] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Ipv4_Bit");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_RCV_IPV6] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Ipv6_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_RCV_IPV6] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Ipv6_Bit");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_RCV_TCP] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_RCV_TCP] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Bit");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_RCV_DUP_TCP] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Dup_Tcp_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_RCV_DUP_TCP] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Dup_Tcp_Bit");
    p_fs2_rt->fs_id_length_array[SAPP_STAT_TCP_LOST_PKT] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Lost_Bit");	
	p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_LOST_PKT_STREAM_NUM] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Lost_STM");	

	p_fs2_rt->fs_id_count_array[SAPP_STAT_DUP_IDENTIFY_ERR] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Dup_Key_Err"); /* dup�ظ���ʶ������key������� */	

    p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_CLOSE_BY_TIMEOUT] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Close_byT");	
	p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_CLOSE_BY_KICKOUT] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Close_byK");	
	
	p_fs2_rt->fs_id_count_array[SAPP_STAT_RCV_UDP] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_RCV_UDP] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Bit");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_RCV_DUP_UDP] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Dup_Udp_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_RCV_DUP_UDP] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Dup_Udp_Bit");

    p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_CLOSE_BY_TIMEOUT] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Close_byT");	
	p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_CLOSE_BY_KICKOUT] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Close_byK");	

	p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_STREAM_NEW] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Link_New");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_STREAM_DEL] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Link_Del");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_STREAM_DATA] = FS_register(fs2_handle, FS_STYLE_STATUS, FS_CALC_CURRENT, "Tcp_Concurrent");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_STREAM_NEW] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Link_New");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_STREAM_DEL] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Link_Del");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_STREAM_MORE] = FS_register(fs2_handle, FS_STYLE_STATUS, FS_CALC_CURRENT, "Udp_Concurrent");
	

    p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_STREAM_DOUBLE] = FS_register(fs2_handle, FS_STYLE_STATUS,FS_CALC_CURRENT, "Tcp_Link_Double");
    p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_STREAM_C2S] = FS_register(fs2_handle,FS_STYLE_STATUS, FS_CALC_CURRENT, "Tcp_Link_C2S");
    p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_STREAM_S2C] = FS_register(fs2_handle,FS_STYLE_STATUS, FS_CALC_CURRENT, "Tcp_Link_S2C");

    p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_STREAM_TOTAL_DOUBLE] = FS_register(fs2_handle, FS_STYLE_STATUS,FS_CALC_CURRENT, "Tcp_Link_Double_ALL");
    p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_STREAM_TOTAL_C2S] = FS_register(fs2_handle,FS_STYLE_STATUS, FS_CALC_CURRENT, "Tcp_Link_C2S_ALL");
    p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_STREAM_TOTAL_S2C] = FS_register(fs2_handle,FS_STYLE_STATUS, FS_CALC_CURRENT, "Tcp_Link_S2C_ALL");
 

    p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_STREAM_DOUBLE] = FS_register(fs2_handle, FS_STYLE_STATUS,FS_CALC_CURRENT, "Udp_Link_Double");
    p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_STREAM_C2S] = FS_register(fs2_handle,FS_STYLE_STATUS, FS_CALC_CURRENT, "Udp_Link_C2S");
    p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_STREAM_S2C] = FS_register(fs2_handle,FS_STYLE_STATUS, FS_CALC_CURRENT, "Udp_Link_S2C");

    p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_STREAM_TOTAL_DOUBLE] = FS_register(fs2_handle, FS_STYLE_STATUS,FS_CALC_CURRENT, "Udp_Link_Double_ALL");
    p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_STREAM_TOTAL_C2S] = FS_register(fs2_handle,FS_STYLE_STATUS, FS_CALC_CURRENT, "Udp_Link_C2S_ALL");
    p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_STREAM_TOTAL_S2C] = FS_register(fs2_handle,FS_STYLE_STATUS, FS_CALC_CURRENT, "Udp_Link_S2C_ALL");


    p_fs2_rt->fs_id_count_array[SAPP_STAT_SND_TCP_RST] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Send_Tcp_Rst");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_SND_TCP_SYNACK] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Send_Tcp_S/A");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_SND_UDP] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Send_Udp");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_SND_CTRL] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Send_CTRL");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_BUILD_LAYER_ERR] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Build_LAYER_Err");
	p_fs2_rt->fs_id_count_array[SAPP_STAT_BUILD_CTRL_ERR] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Build_CTRL_Err");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_GLOBAL_BYPASS] = FS_register(fs2_handle,FS_STYLE_STATUS, FS_CALC_CURRENT, "DDOS_Bypass");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_BYPASS_STREAM] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Bypass_STM");	
	p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_BYPASS_PKTS] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Bypass_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_TCP_BYPASS_BYTES] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Bypass_Bit");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_BYPASS_STREAM] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Bypass_STM");	
	p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_BYPASS_PKTS] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Bypass_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_UDP_BYPASS_BYTES] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Bypass_Bit");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_OFFLOAD_STREAM] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Offload_STM");	
	p_fs2_rt->fs_id_count_array[SAPP_STAT_TCP_OFFLOAD_PKTS] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Offload_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_TCP_OFFLOAD_BYTES] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Tcp_Offload_Bit");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_OFFLOAD_STREAM] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Offload_STM");	
	p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_OFFLOAD_PKTS] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Offload_Pkt");
	p_fs2_rt->fs_id_length_array[SAPP_STAT_UDP_OFFLOAD_BYTES] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_Offload_Bit");

	p_fs2_rt->fs_id_count_array[SAPP_STAT_UDP_DUP_KICK_STREAM] = FS_register(fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "Udp_DUP_STM");
	
	return 0;
}

static void sapp_fs2_destroy(sapp_global_t *global_paramters)
{
	sapp_config_profiling_metric_t *p_fs2_para = &global_paramters->config.profiling.fs2;
	sapp_gval_individual_fixed_fs2_t *p_fs2_rt = &global_paramters->individual_fixed.fs2_runtime;
	if (strlen(p_fs2_para->prometheus_service_uri) > 0 && p_fs2_para->prometheus_service_port > 0)
	{
		FS_library_destroy();
	}

	if (p_fs2_rt->fs_metric_handle)
	{
		FS_stop(&p_fs2_rt->fs_metric_handle);
	}
}


static int sapp_fs2_start(sapp_global_t *global_paramters)
{
	sapp_gval_individual_fixed_fs2_t *p_fs2_rt = &global_paramters->individual_fixed.fs2_runtime;
	void *fs2_handle = p_fs2_rt->fs_metric_handle;
	FS_start(fs2_handle);
	return 0;
}

void sapp_fs3_metric_set(int metric_idx, int metric_idy, long long value)
{
	sapp_gval_individual_fixed_fs3_t *fs3_rt = &sapp_global_val->individual_fixed.fs3_runtime;
	if(fs3_rt->fs_metric_handle!=NULL)
	{
		fieldstat_value_set(fs3_rt->fs_metric_handle, 
								fs3_rt->metrics_ids[metric_idx][metric_idy], 
								value);
	}
	return;
}

void sapp_fs3_metric_incrby(int column_idx, int column_idy,long long value)
{
	sapp_gval_individual_fixed_fs3_t *fs3_rt = &sapp_global_val->individual_fixed.fs3_runtime;
	if(fs3_rt->fs_metric_handle!=NULL)
	{
		fieldstat_value_incrby(fs3_rt->fs_metric_handle, 
								fs3_rt->metrics_ids[column_idx][column_idy], 
								value);
	}
	return;
}

static int sapp_fs3_init(sapp_global_t *global_paramters)
{
	sapp_config_profiling_metric_t *fs3_para = &global_paramters->config.profiling.fs3;
	sapp_gval_individual_fixed_fs3_t *fs3_rt = &global_paramters->individual_fixed.fs3_runtime;

	fs3_rt->fs_metric_handle = fieldstat_instance_new(fs3_para->app_name);
	if(fs3_rt->fs_metric_handle == NULL)
	{
		return -1;
	}
	struct fieldstat_instance *fs3_handle = fs3_rt->fs_metric_handle;
	fieldstat_set_output_interval(fs3_handle, fs3_para->refresh_interval_s * 1000);
	if(strlen(fs3_para->local_file) > 0)
	{
		fieldstat_set_local_output(fs3_handle, ABBR_FS3_LOG_DATA_FILE, "default");
	}
	if(strlen(fs3_para->prometheus_service_uri) > 0 && fs3_para->prometheus_service_port > 0)
	{
		fieldstat_global_enable_prometheus_endpoint(fs3_para->prometheus_service_port, fs3_para->prometheus_service_uri);
		fieldstat_enable_prometheus_output(fs3_handle);
	}	


	fs3_rt->metrics_ids[0][SAPP_STAT_RCV_LINE] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Line_Pkt", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_RCV_LINE] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Line_Bit", 
								NULL, 0);								

	fs3_rt->metrics_ids[0][SAPP_STAT_RCV_ETHERNET] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Eth_Pkt", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_RCV_ETHERNET] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Eth_Bit", 
								NULL, 0);		

	fs3_rt->metrics_ids[0][SAPP_STAT_ETH_INBOUND] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Pkt_Inbound", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_ETH_INBOUND] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Bit_Inbound", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_ETH_OUTBOUND] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Pkt_Outbound", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_ETH_OUTBOUND] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Bit_Outbound", 
								NULL, 0);	


	fs3_rt->metrics_ids[0][SAPP_STAT_RCV_UNKNOWN] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Unknown_Pkt", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_RCV_UNKNOWN] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Unknown_Bit", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_SND_ERROR] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Snd_Err_Pkt", 
								NULL, 0);

	fs3_rt->metrics_ids[0][SAPP_STAT_RCV_IPV4] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Ipv4_Pkt", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_RCV_IPV4] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Ipv4_Bit", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_RCV_IPV6] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Ipv6_Pkt", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_RCV_IPV6] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Ipv6_Bit", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_RCV_TCP] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Pkt", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_RCV_TCP] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Bit", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_RCV_DUP_TCP] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Dup_Tcp_Pkt", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_RCV_DUP_TCP] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Dup_Tcp_Bit", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_LOST_PKT_STREAM_NUM] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Lost_STM", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_TCP_LOST_PKT] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Lost_Bit", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_DUP_IDENTIFY_ERR] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Dup_Key_Err", 
								NULL, 0);

	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_CLOSE_BY_TIMEOUT] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Close_byT", 
								NULL, 0);
	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_CLOSE_BY_KICKOUT] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Close_byK", 
								NULL, 0);								

	fs3_rt->metrics_ids[0][SAPP_STAT_RCV_UDP] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Pkt", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_RCV_UDP] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Bit", 
								NULL, 0);		
	fs3_rt->metrics_ids[0][SAPP_STAT_RCV_DUP_UDP] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Dup_Udp_Pkt", 
								NULL, 0);
	fs3_rt->metrics_ids[1][SAPP_STAT_RCV_DUP_UDP] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Dup_Udp_Bit", 
								NULL, 0);									

	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_CLOSE_BY_TIMEOUT] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Close_byT", 
								NULL, 0);
	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_CLOSE_BY_KICKOUT] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Close_byK", 
								NULL, 0);		

	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_NEW] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Link_New", 
								NULL, 0);
	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_DEL] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Link_Del", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_DATA] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Tcp_Concurrent", 
								NULL, 0);									

	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_NEW] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Link_New", 
								NULL, 0);
	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_DEL] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Link_Del", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_MORE] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Udp_Concurrent", 
								NULL, 0);	


	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_DOUBLE] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Tcp_Link_Double", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_C2S] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Tcp_Link_C2S", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_S2C] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Tcp_Link_S2C", 
								NULL, 0);									

	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_TOTAL_DOUBLE] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Tcp_Link_Double_ALL", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_TOTAL_C2S] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Tcp_Link_C2S_ALL", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_TOTAL_S2C] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Tcp_Link_S2C_ALL", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_DOUBLE] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Udp_Link_Double", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_C2S] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Udp_Link_C2S", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_S2C] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Udp_Link_S2C", 
								NULL, 0);									

	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_TOTAL_DOUBLE] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Udp_Link_Double_ALL", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_TOTAL_C2S] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Udp_Link_C2S_ALL", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_TOTAL_S2C] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "Udp_Link_S2C_ALL", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_SND_TCP_RST] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Send_Tcp_Rst", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_SND_TCP_SYNACK] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Send_Tcp_S/A", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_SND_UDP] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Send_Udp", 
								NULL, 0);		

	fs3_rt->metrics_ids[0][SAPP_STAT_SND_CTRL] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Send_CTRL", 
								NULL, 0);										
	
	fs3_rt->metrics_ids[0][SAPP_STAT_BUILD_LAYER_ERR] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Build_Layer_Err", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_BUILD_CTRL_ERR] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Build_CTRL_Err", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_GLOBAL_BYPASS] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "DDOS_Bypass", 
								NULL, 0);	

	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_BYPASS_STREAM] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Bypass_STM", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_BYPASS_PKTS] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Bypass_Pkt", 
								NULL, 0);	
	fs3_rt->metrics_ids[1][SAPP_STAT_TCP_BYPASS_BYTES] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Bypass_Bit", 
								NULL, 0);								

	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_BYPASS_STREAM] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Bypass_STM", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_BYPASS_PKTS] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Bypass_Pkt", 
								NULL, 0);	
	fs3_rt->metrics_ids[1][SAPP_STAT_UDP_BYPASS_BYTES] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Bypass_Bit", 
								NULL, 0);	

	//fs3_rt->metrics_ids[0][SAPP_STAT_TCP_OFFLOAD_STREAM] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Offload_STM", 
	//							NULL, 0);	
	//fs3_rt->metrics_ids[0][SAPP_STAT_TCP_OFFLOAD_PKTS] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Offload_Pkt", 
	//							NULL, 0);	
	//fs3_rt->metrics_ids[1][SAPP_STAT_TCP_OFFLOAD_BYTES] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_Offload_Bit", 
	//							NULL, 0);	

	//fs3_rt->metrics_ids[0][SAPP_STAT_UDP_OFFLOAD_STREAM] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Offload_STM", 
	//							NULL, 0);	
	//fs3_rt->metrics_ids[0][SAPP_STAT_UDP_OFFLOAD_PKTS] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Offload_Pkt", 
	//							NULL, 0);	
	//fs3_rt->metrics_ids[1][SAPP_STAT_UDP_OFFLOAD_BYTES] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_Offload_Bit", 
	//							NULL, 0);	
								
	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_DUP_KICK_STREAM] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_DUP_STM", 
								NULL, 0);									

	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_OPENING_OVERSPEED] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_OPEN_SPD", 
								NULL, 0);									

	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_OPENING_OVERSPEED] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_OPEN_SPD", 
								NULL, 0);									

	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_TIMEOUTS_OVERSPEED] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_TIMED_SPD", 
								NULL, 0);									

	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_TIMEOUTS_OVERSPEED] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_TIMED_SPD", 
								NULL, 0);									

	fs3_rt->metrics_ids[0][SAPP_STAT_TCP_TRY_TIMEOUTS] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Tcp_TRY_TIMED", 
								NULL, 0);	
	fs3_rt->metrics_ids[0][SAPP_STAT_UDP_TRY_TIMEOUTS] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "Udp_TRY_TIMED", 
								NULL, 0);					

	const sapp_dup_pkt_t *dup_cfg = &global_paramters->config.packet_io.dup_pkt_para;
	if (dup_cfg->kickout_udp_stream_enabled 
	  || dup_cfg->dup_pkt_distinguish_ipv4_tcp 
	  || dup_cfg->dup_pkt_distinguish_ipv4_udp 
	  || dup_cfg->dup_pkt_distinguish_all_inject)
	{
		fs3_rt->metrics_ids[0][SAPP_STAT_BM_HASH_NUM] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "BM_HASH_NUM",  NULL, 0);	
		fs3_rt->metrics_ids[0][SAPP_STAT_BM_EXPAND_NUM] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "BM_EXPAND", NULL, 0);	
		fs3_rt->metrics_ids[0][SAPP_STAT_BM_SLICE_NUM_NEW] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "BM_SLICE_NEW", NULL, 0);	
		fs3_rt->metrics_ids[0][SAPP_STAT_BM_SLICE_NUM_FREE] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_COUNTER, "BM_SLICE_FREE", NULL, 0);			
		fs3_rt->metrics_ids[0][SAPP_STAT_BM_CUR_SLICE_NUM] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "BM_MAX_SLICE", NULL, 0);	
		fs3_rt->metrics_ids[0][SAPP_STAT_APBM_EXPAND_MAX_MULTIPLE] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "APBM_EXPAND_MULTIPLE", NULL, 0);
		fs3_rt->metrics_ids[0][SAPP_STAT_DABM_RESIZE_MAX_RATIO] = fieldstat_register(fs3_handle, FIELD_METRIC_TYPE_GAUGE, "DABM_MAX_RESIZE_RATIO", NULL, 0);
	}
								
	return 0;
}

static int sapp_fs3_start(sapp_global_t *global_paramters)
{
	sapp_gval_individual_fixed_fs3_t *fs3_rt = &global_paramters->individual_fixed.fs3_runtime;
	struct fieldstat_instance *fs3_handle = fs3_rt->fs_metric_handle;
	// TODO: histogram for process lanency							
	fieldstat_instance_start(fs3_handle);
	return 0;
}

static void sapp_fs3_destroy(sapp_global_t *global_paramters)
{
	sapp_gval_individual_fixed_fs3_t *fs3_rt = &global_paramters->individual_fixed.fs3_runtime;
	if(fs3_rt->fs_metric_handle != NULL)
	{
		fieldstat_instance_free(fs3_rt->fs_metric_handle);
	}
	fs3_rt->fs_metric_handle=NULL;
	return;
}

void sapp_fs4_metric_set(int column_idx, int column_idy, long long value)
{
	sapp_gval_individual_fixed_fs4_t *fs4_rt = &sapp_global_val->individual_fixed.fs4_runtime;
	if(fs4_rt->fs_metric_handle!=NULL)
	{
		fieldstat_easy_counter_set(fs4_rt->fs_metric_handle, 
								0,
								fs4_rt->metrics_ids[column_idx][column_idy], 
								NULL,
								0,
								value);
	}
	return;
}

void sapp_fs4_metric_incrby(int column_idx, int column_idy,long long value)
{
	sapp_gval_individual_fixed_fs4_t *fs4_rt = &sapp_global_val->individual_fixed.fs4_runtime;
	if(fs4_rt->fs_metric_handle!=NULL)
	{
		fieldstat_easy_counter_incrby(fs4_rt->fs_metric_handle, 
								0,
								fs4_rt->metrics_ids[column_idx][column_idy], 
								NULL,
								0,
								value);
	}
	return;
}

static int sapp_fs4_init(sapp_global_t *global_paramters)
{
	sapp_config_profiling_metric_t *fs4_para = &global_paramters->config.profiling.fs4;
	sapp_gval_individual_fixed_fs4_t *fs4_rt = &global_paramters->individual_fixed.fs4_runtime;

	fs4_rt->fs_metric_handle = fieldstat_easy_new(1, fs4_para->app_name, NULL, 0);
	if(fs4_rt->fs_metric_handle == NULL)
	{
		return -1;
	}
	struct fieldstat_easy *fs4_handle = fs4_rt->fs_metric_handle;

	fs4_rt->metrics_ids[0][SAPP_STAT_RCV_LINE] = fieldstat_easy_register_counter(fs4_handle, "Line_Pkt");
	fs4_rt->metrics_ids[1][SAPP_STAT_RCV_LINE] = fieldstat_easy_register_counter(fs4_handle, "Line_Bit");								

	fs4_rt->metrics_ids[0][SAPP_STAT_RCV_ETHERNET] = fieldstat_easy_register_counter(fs4_handle, "Eth_Pkt");
	fs4_rt->metrics_ids[1][SAPP_STAT_RCV_ETHERNET] = fieldstat_easy_register_counter(fs4_handle, "Eth_Bit");	

	fs4_rt->metrics_ids[0][SAPP_STAT_ETH_INBOUND] = fieldstat_easy_register_counter(fs4_handle, "Pkt_Inbound");
	fs4_rt->metrics_ids[1][SAPP_STAT_ETH_INBOUND] = fieldstat_easy_register_counter(fs4_handle, "Bit_Inbound");	

	fs4_rt->metrics_ids[0][SAPP_STAT_ETH_OUTBOUND] = fieldstat_easy_register_counter(fs4_handle, "Pkt_Outbound");
	fs4_rt->metrics_ids[1][SAPP_STAT_ETH_OUTBOUND] = fieldstat_easy_register_counter(fs4_handle, "Bit_Outbound");	

	fs4_rt->metrics_ids[0][SAPP_STAT_RCV_UNKNOWN] = fieldstat_easy_register_counter(fs4_handle, "Unknown_Pkt");
	fs4_rt->metrics_ids[1][SAPP_STAT_RCV_UNKNOWN] = fieldstat_easy_register_counter(fs4_handle, "Unknown_Bit");

	fs4_rt->metrics_ids[0][SAPP_STAT_SND_ERROR] = fieldstat_easy_register_counter(fs4_handle, "Snd_Err_Pkt");

	fs4_rt->metrics_ids[0][SAPP_STAT_RCV_IPV4] = fieldstat_easy_register_counter(fs4_handle, "Ipv4_Pkt");
	fs4_rt->metrics_ids[1][SAPP_STAT_RCV_IPV4] = fieldstat_easy_register_counter(fs4_handle, "Ipv4_Bit");


	fs4_rt->metrics_ids[0][SAPP_STAT_RCV_IPV6] = fieldstat_easy_register_counter(fs4_handle, "Ipv6_Pkt");
	fs4_rt->metrics_ids[1][SAPP_STAT_RCV_IPV6] = fieldstat_easy_register_counter(fs4_handle, "Ipv6_Bit");

	fs4_rt->metrics_ids[0][SAPP_STAT_RCV_TCP] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Pkt");
	fs4_rt->metrics_ids[1][SAPP_STAT_RCV_TCP] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Bit");

	fs4_rt->metrics_ids[0][SAPP_STAT_RCV_DUP_TCP] = fieldstat_easy_register_counter(fs4_handle, "Dup_Tcp_Pkt");
	fs4_rt->metrics_ids[1][SAPP_STAT_RCV_DUP_TCP] = fieldstat_easy_register_counter(fs4_handle, "Dup_Tcp_Bit");

	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_LOST_PKT_STREAM_NUM] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Lost_STM");

	fs4_rt->metrics_ids[1][SAPP_STAT_TCP_LOST_PKT] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Lost_Bit");

	//fs4_rt->metrics_ids[0][SAPP_STAT_DUP_IDENTIFY_ERR] = fieldstat_easy_register_counter(fs4_handle, "Dup_Key_Err");

	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_CLOSE_BY_TIMEOUT] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Close_byT");

	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_CLOSE_BY_KICKOUT] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Close_byK");

	fs4_rt->metrics_ids[0][SAPP_STAT_RCV_UDP] = fieldstat_easy_register_counter(fs4_handle, "Udp_Pkt");
	fs4_rt->metrics_ids[1][SAPP_STAT_RCV_UDP] = fieldstat_easy_register_counter(fs4_handle, "Udp_Bit");

	fs4_rt->metrics_ids[0][SAPP_STAT_RCV_DUP_UDP] = fieldstat_easy_register_counter(fs4_handle, "Dup_Udp_Pkt");
	fs4_rt->metrics_ids[1][SAPP_STAT_RCV_DUP_UDP] = fieldstat_easy_register_counter(fs4_handle, "Dup_Udp_Bit");

	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_CLOSE_BY_TIMEOUT] = fieldstat_easy_register_counter(fs4_handle, "Udp_Close_byT");

	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_CLOSE_BY_KICKOUT] = fieldstat_easy_register_counter(fs4_handle, "Udp_Close_byK");							

	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_NEW] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Link_New");
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_DEL] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Link_Del");		
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_DATA] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Concurrent");		

	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_NEW] = fieldstat_easy_register_counter(fs4_handle, "Udp_Link_New");
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_DEL] = fieldstat_easy_register_counter(fs4_handle, "Udp_Link_Del");		
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_MORE] = fieldstat_easy_register_counter(fs4_handle, "Udp_Concurrent");	

	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_DOUBLE] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Link_Double");
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_C2S] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Link_C2S");		
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_S2C] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Link_S2C");	

	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_TOTAL_DOUBLE] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Link_Double_ALL");
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_TOTAL_C2S] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Link_C2S_ALL");		
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_STREAM_TOTAL_S2C] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Link_S2C_ALL");	
								

	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_DOUBLE] = fieldstat_easy_register_counter(fs4_handle, "Udp_Link_Double");
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_C2S] = fieldstat_easy_register_counter(fs4_handle, "Udp_Link_C2S");		
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_S2C] = fieldstat_easy_register_counter(fs4_handle, "Udp_Link_S2C");	

	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_TOTAL_DOUBLE] = fieldstat_easy_register_counter(fs4_handle, "Udp_Link_Double_ALL");
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_TOTAL_C2S] = fieldstat_easy_register_counter(fs4_handle, "Udp_Link_C2S_ALL");		
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_STREAM_TOTAL_S2C] = fieldstat_easy_register_counter(fs4_handle, "Udp_Link_S2C_ALL");	

	fs4_rt->metrics_ids[0][SAPP_STAT_SND_TCP_RST] = fieldstat_easy_register_counter(fs4_handle, "Send_Tcp_Rst");
	fs4_rt->metrics_ids[0][SAPP_STAT_SND_TCP_SYNACK] = fieldstat_easy_register_counter(fs4_handle, "Send_Tcp_S/A");		
	fs4_rt->metrics_ids[0][SAPP_STAT_SND_UDP] = fieldstat_easy_register_counter(fs4_handle, "Send_Udp");	
	fs4_rt->metrics_ids[0][SAPP_STAT_SND_CTRL] = fieldstat_easy_register_counter(fs4_handle, "Send_CTRL");	

	fs4_rt->metrics_ids[0][SAPP_STAT_BUILD_LAYER_ERR] = fieldstat_easy_register_counter(fs4_handle, "Build_Layer_Err");		
	fs4_rt->metrics_ids[0][SAPP_STAT_BUILD_CTRL_ERR] = fieldstat_easy_register_counter(fs4_handle, "Build_CTRL_Err");	

	fs4_rt->metrics_ids[0][SAPP_STAT_GLOBAL_BYPASS] = fieldstat_easy_register_counter(fs4_handle, "DDOS_Bypass");	
	
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_BYPASS_STREAM] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Bypass_STM");
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_BYPASS_PKTS] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Bypass_Pkt");		
	fs4_rt->metrics_ids[1][SAPP_STAT_TCP_BYPASS_BYTES] = fieldstat_easy_register_counter(fs4_handle, "Tcp_Bypass_Bit");		
								
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_BYPASS_STREAM] = fieldstat_easy_register_counter(fs4_handle, "Udp_Bypass_STM");
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_BYPASS_PKTS] = fieldstat_easy_register_counter(fs4_handle, "Udp_Bypass_Pkt");		
	fs4_rt->metrics_ids[1][SAPP_STAT_UDP_BYPASS_BYTES] = fieldstat_easy_register_counter(fs4_handle, "Udp_Bypass_Bit");			

	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_DUP_KICK_STREAM] = fieldstat_easy_register_counter(fs4_handle, "Udp_DUP_STM");
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_OPENING_OVERSPEED] = fieldstat_easy_register_counter(fs4_handle, "Tcp_OPEN_SPD");		
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_OPENING_OVERSPEED] = fieldstat_easy_register_counter(fs4_handle, "Udp_OPEN_SPD");
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_TIMEOUTS_OVERSPEED] = fieldstat_easy_register_counter(fs4_handle, "Tcp_TIMED_SPD");		
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_TIMEOUTS_OVERSPEED] = fieldstat_easy_register_counter(fs4_handle, "Udp_TIMED_SPD");							
	fs4_rt->metrics_ids[0][SAPP_STAT_TCP_TRY_TIMEOUTS] = fieldstat_easy_register_counter(fs4_handle, "Tcp_TRY_TIMED");		
	fs4_rt->metrics_ids[0][SAPP_STAT_UDP_TRY_TIMEOUTS] = fieldstat_easy_register_counter(fs4_handle, "Udp_TRY_TIMED");								


	const sapp_dup_pkt_t *dup_cfg = &global_paramters->config.packet_io.dup_pkt_para;
	if (dup_cfg->kickout_udp_stream_enabled 
	  || dup_cfg->dup_pkt_distinguish_ipv4_tcp 
	  || dup_cfg->dup_pkt_distinguish_ipv4_udp 
	  || dup_cfg->dup_pkt_distinguish_all_inject)
	{
		fs4_rt->metrics_ids[0][SAPP_STAT_BM_HASH_NUM] = fieldstat_easy_register_counter(fs4_handle, "BM_HASH_NUM");

		fs4_rt->metrics_ids[0][SAPP_STAT_BM_EXPAND_NUM] = fieldstat_easy_register_counter(fs4_handle, "BM_EXPAND");
		fs4_rt->metrics_ids[0][SAPP_STAT_BM_SLICE_NUM_NEW] = fieldstat_easy_register_counter(fs4_handle, "BM_SLICE_NEW");
		fs4_rt->metrics_ids[0][SAPP_STAT_BM_SLICE_NUM_FREE] = fieldstat_easy_register_counter(fs4_handle, "BM_SLICE_FREE");
		fs4_rt->metrics_ids[0][SAPP_STAT_BM_CUR_SLICE_NUM] = fieldstat_easy_register_counter(fs4_handle, "BM_MAX_SLICE");
		fs4_rt->metrics_ids[0][SAPP_STAT_APBM_EXPAND_MAX_MULTIPLE] = fieldstat_easy_register_counter(fs4_handle, "APBM_EXPAND_MULTIPLE");
		fs4_rt->metrics_ids[0][SAPP_STAT_DABM_RESIZE_MAX_RATIO] = fieldstat_easy_register_counter(fs4_handle, "DABM_MAX_RESIZE_RATIO");
	}	
	return 0;
}

static int sapp_fs4_start(sapp_global_t *global_paramters)
{
	sapp_config_profiling_metric_t *fs4_para = &global_paramters->config.profiling.fs4;
	sapp_gval_individual_fixed_fs4_t *fs4_rt = &global_paramters->individual_fixed.fs4_runtime;
	struct fieldstat_easy *fs4_handle = fs4_rt->fs_metric_handle;

	fieldstat_easy_enable_auto_output(fs4_handle, ABBR_FS4_LOG_DATA_FILE, fs4_para->refresh_interval_s);
	//fieldstat_easy_enable_delta_in_active_output(fs4_handle);
	return 0;
}


static void sapp_fs4_destroy(sapp_global_t *global_paramters)
{
	sapp_gval_individual_fixed_fs4_t *fs4_rt = &global_paramters->individual_fixed.fs4_runtime;
	fieldstat_easy_free(fs4_rt->fs_metric_handle);
}

int sapp_metric_init(void)
{
	int ret = 0;
	if( sapp_global_val->config.profiling.fs2.enabled == 1)
	{
		sapp_fs2_init(sapp_global_val);
	}
	if( sapp_global_val->config.profiling.fs3.enabled == 1)
	{
		sapp_fs3_init(sapp_global_val);
	}
	if( sapp_global_val->config.profiling.fs4.enabled == 1)
	{
		sapp_fs4_init(sapp_global_val);
	}	
	if( sapp_global_val->config.profiling.histogram_enabled == 1)
	{
		sapp_process_latency_metric_init(sapp_global_val);
	}
	
	return ret;
}

int sapp_metric_start(void)
{
	int ret = 0;
	if( sapp_global_val->config.profiling.fs2.enabled == 1)
	{
		sapp_fs2_start(sapp_global_val);
	}
	if( sapp_global_val->config.profiling.fs3.enabled == 1)
	{
		sapp_fs3_start(sapp_global_val);
	}
	if( sapp_global_val->config.profiling.fs4.enabled == 1)
	{
		sapp_fs4_start(sapp_global_val);
	}	
	if( sapp_global_val->config.profiling.histogram_enabled == 1)
	{
		if(sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle)
		{
			FS_start(sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle);
		}
	}
	return ret;
}

void sapp_metric_destroy(void)
{
	
	if( sapp_global_val->config.profiling.fs2.enabled == 1)
	{
		sapp_fs2_destroy(sapp_global_val);
	}
	if( sapp_global_val->config.profiling.fs3.enabled == 1)
	{
		sapp_fs3_destroy(sapp_global_val);
	}
	if( sapp_global_val->config.profiling.fs4.enabled == 1)
	{
		sapp_fs4_destroy(sapp_global_val);
	}	
	if( sapp_global_val->config.profiling.histogram_enabled == 1)
	{
		if (sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle)
		{
			FS_stop(&sapp_global_val->individual_fixed.fs2_runtime.fs_process_lantency_handle);
		}
	}
}