gfwleak/tango-tfe
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

TSG-23378 TFE移除平台层的FieldStat2，为适配AArch64做准备

Browse Source
This commit is contained in:
luwenpeng
2024-11-13 14:09:03 +08:00
parent aa98cf915e
commit 3d99178958
18 changed files with 223 additions and 336 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
common/include/tfe_proxy.h
View File

@@ -1,5 +1,5 @@
#pragma once #pragma once
#include <MESA/field_stat2.h> #include <fieldstat/fieldstat_easy.h>
#include <event2/event.h> #include <event2/event.h>
struct tfe_proxy; struct tfe_proxy;
@@ -9,7 +9,7 @@ struct evdns_base* tfe_proxy_get_work_thread_dnsbase(unsigned int thread_id);
struct evhttp_connection* tfe_proxy_get_work_thread_evhttp(unsigned int thread_id); struct evhttp_connection* tfe_proxy_get_work_thread_evhttp(unsigned int thread_id);
struct event_base * tfe_proxy_get_gc_evbase(void); struct event_base * tfe_proxy_get_gc_evbase(void);
screen_stat_handle_t tfe_proxy_get_fs_handle(void); struct fieldstat_easy *tfe_proxy_get_fs_handle(void);
void * tfe_proxy_get_error_logger(void); void * tfe_proxy_get_error_logger(void);
int tfe_proxy_ssl_add_trust_ca(const char* pem_file); int tfe_proxy_ssl_add_trust_ca(const char* pem_file);

2
common/include/tfe_utils.h
View File

@@ -46,6 +46,7 @@
extern void * g_default_logger; extern void * g_default_logger;
extern bool g_print_to_stderr; extern bool g_print_to_stderr;
extern thread_local unsigned int __currect_thread_id;
#define TFE_LOG_ERROR(handler, fmt, ...) \ #define TFE_LOG_ERROR(handler, fmt, ...) \
do \ do \
@@ -136,6 +137,7 @@ do { if(!(condition)) { TFE_LOG_ERROR(g_default_logger, fmt, ##__VA_ARGS__); abo
#define ATOMIC_ADD(x, y) __atomic_fetch_add(x,y,__ATOMIC_RELAXED) #define ATOMIC_ADD(x, y) __atomic_fetch_add(x,y,__ATOMIC_RELAXED)
#define ATOMIC_ZERO(x) __atomic_fetch_and(x,0,__ATOMIC_RELAXED) #define ATOMIC_ZERO(x) __atomic_fetch_and(x,0,__ATOMIC_RELAXED)
#define ATOMIC_SET(x,y) __atomic_store_n(x,y,__ATOMIC_RELAXED) #define ATOMIC_SET(x,y) __atomic_store_n(x,y,__ATOMIC_RELAXED)
#define ATOMIC_EXCHANGE(x,y) __atomic_exchange_n(x,y,__ATOMIC_RELAXED)
#ifndef MAX #ifndef MAX
#define MAX(a, b) (((a) > (b)) ? (a) : (b)) #define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif #endif

118
common/src/tfe_future.cpp
View File

@@ -7,9 +7,8 @@
#include <tfe_future.h> #include <tfe_future.h>
#include <tfe_utils.h> #include <tfe_utils.h>
#include <MESA/MESA_htable.h> #include <MESA/MESA_htable.h>
#include <MESA/field_stat2.h>
#include <MESA/MESA_prof_load.h> #include <MESA/MESA_prof_load.h>
#include <fieldstat/fieldstat_easy.h>
static const char* FP_HISTOGRAM_BINS="0.50,0.80,0.9,0.95,0.99"; static const char* FP_HISTOGRAM_BINS="0.50,0.80,0.9,0.95,0.99";
@@ -17,15 +16,8 @@ struct future_promise_instance
{ {
int fsid_f_num; int fsid_f_num;
long long f_num; long long f_num;
int no_stats;
int statsd_cycle;
int statsd_format;
MESA_htable_handle name_table; MESA_htable_handle name_table;
char statsd_server_ip[256]; struct fieldstat_easy *fs_handle;
int statsd_server_port;
enum field_calc_algo favorite;
char histogram_bins[256];
screen_stat_handle_t fs_handle;
}; };
struct _future_promise_debug struct _future_promise_debug
@@ -64,76 +56,34 @@ void future_promise_library_init(const char* profile)
return; return;
} }
int value=0;
memset(&g_FP_instance, 0, sizeof(g_FP_instance)); memset(&g_FP_instance, 0, sizeof(g_FP_instance));
g_FP_instance.favorite=FS_CALC_CURRENT; int output_cycle = 0;
strcpy(g_FP_instance.histogram_bins, FP_HISTOGRAM_BINS); char output_file[TFE_STRING_MAX] = {0};
if(profile!=NULL) char histogram_bins[256] = {0};
{
MESA_load_profile_int_def(profile, "STAT", "no_stats", &(g_FP_instance.no_stats), 0);
MESA_load_profile_string_def(profile, "STAT", "statsd_server",
g_FP_instance.statsd_server_ip, sizeof(g_FP_instance.statsd_server_ip), "");
MESA_load_profile_int_def(profile, "STAT", "statsd_port", &(g_FP_instance.statsd_server_port), 0);
MESA_load_profile_int_def(profile, "STAT", "statsd_cycle", &(g_FP_instance.statsd_cycle), 2);
// FS_OUTPUT_STATSD=1, FS_OUTPUT_INFLUX_LINE=2
MESA_load_profile_int_def(profile, "STAT", "statsd_format", &(g_FP_instance.statsd_format), 1);
MESA_load_profile_string_def(profile, "STAT", "histogram_bins",
g_FP_instance.histogram_bins, sizeof(g_FP_instance.histogram_bins), FP_HISTOGRAM_BINS);
MESA_load_profile_int_def(profile, "STAT", "print_diff",
&value, 1);
if(value==0)
{
g_FP_instance.favorite=FS_CALC_CURRENT;
}
}
if(g_FP_instance.no_stats)
{
g_is_FP_init=1;
return;
}
if (g_FP_instance.statsd_format != 1 && g_FP_instance.statsd_format != 2) unsigned int nr_worker_threads = 0;
{ MESA_load_profile_uint_def(profile, "system", "nr_worker_threads", &nr_worker_threads, 1);
g_FP_instance.statsd_format = 1;
} MESA_load_profile_int_def(profile, "STAT", "output_cycle", &output_cycle, 2);
MESA_load_profile_string_def(profile, "STAT", "output_file", output_file, sizeof(output_file), "log/future.fs4");
MESA_load_profile_string_def(profile, "STAT", "histogram_bins", histogram_bins, sizeof(histogram_bins), FP_HISTOGRAM_BINS);
MESA_htable_handle htable = MESA_htable_born(); MESA_htable_handle htable = MESA_htable_born();
value=0; int value = 0;
MESA_htable_set_opt(htable, MHO_SCREEN_PRINT_CTRL, &value, sizeof(value)); MESA_htable_set_opt(htable, MHO_SCREEN_PRINT_CTRL, &value, sizeof(value));
value = 1; value = 1;
MESA_htable_set_opt(htable, MHO_THREAD_SAFE, &value,sizeof(value));; MESA_htable_set_opt(htable, MHO_THREAD_SAFE, &value, sizeof(value));
value = 16; value = 16;
MESA_htable_set_opt(htable, MHO_MUTEX_NUM, &value,sizeof(value));; MESA_htable_set_opt(htable, MHO_MUTEX_NUM, &value, sizeof(value));
value = 1024; value = 1024;
MESA_htable_set_opt(htable, MHO_HASH_SLOT_SIZE, &value,sizeof(value));; MESA_htable_set_opt(htable, MHO_HASH_SLOT_SIZE, &value, sizeof(value));
MESA_htable_mature(htable); MESA_htable_mature(htable);
g_FP_instance.name_table = htable; g_FP_instance.name_table = htable;
screen_stat_handle_t fs=NULL; g_FP_instance.fs_handle = fieldstat_easy_new(nr_worker_threads, "FP", NULL, 0);
const char* stat_path="log/future.fs2"; fieldstat_easy_enable_auto_output(g_FP_instance.fs_handle, output_file, output_cycle);
const char* app_name="FP"; g_FP_instance.fsid_f_num = fieldstat_easy_register_counter(g_FP_instance.fs_handle, "futures");
fs=FS_create_handle();
FS_set_para(fs, APP_NAME, app_name, strlen(app_name)+1);
value=1;
FS_set_para(fs, OUTPUT_PROMETHEUS, &value, sizeof(value));
value=0;
FS_set_para(fs, FLUSH_BY_DATE, &value, sizeof(value));
FS_set_para(fs, OUTPUT_DEVICE, stat_path, strlen(stat_path)+1);
value=1;
FS_set_para(fs, PRINT_MODE, &value, sizeof(value));
value=1;
FS_set_para(fs, CREATE_THREAD, &value, sizeof(value));
FS_set_para(fs, STAT_CYCLE, &g_FP_instance.statsd_cycle, sizeof(g_FP_instance.statsd_cycle));
if(strlen(g_FP_instance.statsd_server_ip)>0 && g_FP_instance.statsd_server_port!=0)
{
FS_set_para(fs, STATS_SERVER_IP, g_FP_instance.statsd_server_ip, strlen(g_FP_instance.statsd_server_ip)+1);
FS_set_para(fs, STATS_SERVER_PORT, &(g_FP_instance.statsd_server_port), sizeof(g_FP_instance.statsd_server_port));
FS_set_para(fs, STATS_FORMAT, &(g_FP_instance.statsd_format), sizeof(g_FP_instance.statsd_format));
}
FS_set_para(fs, HISTOGRAM_GLOBAL_BINS, g_FP_instance.histogram_bins, strlen(g_FP_instance.histogram_bins)+1);
g_FP_instance.fsid_f_num=FS_register(fs, FS_STYLE_FIELD, g_FP_instance.favorite, "futures");
FS_start(fs);
g_FP_instance.fs_handle=fs;
g_is_FP_init = 1; g_is_FP_init = 1;
return; return;
} }
@@ -147,7 +97,9 @@ static void __promise_destroy(struct promise *p)
{ {
p->cb_ctx_destroy(p->ctx); p->cb_ctx_destroy(p->ctx);
} }
if(!g_FP_instance.no_stats) FS_operate(g_FP_instance.fs_handle,g_FP_instance.fsid_f_num, 0, FS_OP_SUB, 1);
fieldstat_easy_counter_incrby(g_FP_instance.fs_handle, __currect_thread_id, g_FP_instance.fsid_f_num, NULL, 0, -1);
memset(p, 0, sizeof(struct promise)); memset(p, 0, sizeof(struct promise));
free(p); free(p);
return; return;
@@ -172,7 +124,7 @@ void promise_allow_many_successes(struct promise *p)
struct field_get_set_args struct field_get_set_args
{ {
MESA_htable_handle htable; MESA_htable_handle htable;
screen_stat_handle_t fs_handle; struct fieldstat_easy *fs_handle;
int fsid_latency; int fsid_latency;
int fsid_failed; int fsid_failed;
}; };
@@ -185,13 +137,15 @@ static long field_get_set_cb(void * data, const uchar * key, uint size, void * u
if (data == NULL) if (data == NULL)
{ {
field_id = (int *)malloc(sizeof(int) * 2); field_id = (int *)malloc(sizeof(int) * 2);
snprintf(buff, sizeof(buff), "%s(ms)", (char *)key); snprintf(buff, sizeof(buff), "%s(ms)", (char *)key);
field_id[0]=FS_register_histogram(args->fs_handle, g_FP_instance.favorite, buff, field_id[0] = fieldstat_easy_register_histogram(args->fs_handle, buff, 1, 500000, 1);
1, 30*1000,3);
args->fsid_latency = field_id[0]; args->fsid_latency = field_id[0];
snprintf(buff, sizeof(buff), "%s%s", (char *)key, fail_str); snprintf(buff, sizeof(buff), "%s%s", (char *)key, fail_str);
field_id[1]=FS_register(args->fs_handle, FS_STYLE_FIELD, g_FP_instance.favorite, buff); field_id[1] = fieldstat_easy_register_counter(args->fs_handle, buff);
args->fsid_failed = field_id[1]; args->fsid_failed = field_id[1];
ret = MESA_htable_add(args->htable, key, size, (void *)field_id); ret = MESA_htable_add(args->htable, key, size, (void *)field_id);
assert(ret >= 0); assert(ret >= 0);
} }
@@ -214,16 +168,16 @@ struct future * future_create(const char* symbol, future_success_cb * cb_success
p->f.cb_failed = cb_failed; p->f.cb_failed = cb_failed;
p->ref_cnt = 1; p->ref_cnt = 1;
strncpy(p->f.symbol, symbol, sizeof(p->f.symbol)); strncpy(p->f.symbol, symbol, sizeof(p->f.symbol));
if(!g_FP_instance.no_stats)
{
clock_gettime(CLOCK_MONOTONIC, &p->debug.create_time); clock_gettime(CLOCK_MONOTONIC, &p->debug.create_time);
long cb_ret = 0; long cb_ret = 0;
struct field_get_set_args args = {.htable = g_FP_instance.name_table, .fs_handle = g_FP_instance.fs_handle}; struct field_get_set_args args = {.htable = g_FP_instance.name_table, .fs_handle = g_FP_instance.fs_handle};
MESA_htable_search_cb(g_FP_instance.name_table, (const unsigned char *)symbol, strlen(symbol), field_get_set_cb, &args, &cb_ret); MESA_htable_search_cb(g_FP_instance.name_table, (const unsigned char *)symbol, strlen(symbol), field_get_set_cb, &args, &cb_ret);
p->debug.fsid_latency = args.fsid_latency; p->debug.fsid_latency = args.fsid_latency;
p->debug.fsid_failed = args.fsid_failed; p->debug.fsid_failed = args.fsid_failed;
FS_operate(g_FP_instance.fs_handle,g_FP_instance.fsid_f_num, 0, FS_OP_ADD, 1);
} fieldstat_easy_counter_incrby(g_FP_instance.fs_handle, __currect_thread_id, g_FP_instance.fsid_f_num, NULL, 0, 1);
return &p->f; return &p->f;
} }
void future_set_timeout(struct future * f, struct timeval timeout) void future_set_timeout(struct future * f, struct timeval timeout)
@@ -266,18 +220,18 @@ static void fp_stat_latency(struct _future_promise_debug* debug, int is_success)
} }
else else
{ {
FS_operate(g_FP_instance.fs_handle, debug->fsid_failed, 0, FS_OP_ADD, 1); fieldstat_easy_counter_incrby(g_FP_instance.fs_handle, __currect_thread_id, debug->fsid_failed, NULL, 0, 1);
} }
if (debug->succ_times <= 1) if (debug->succ_times <= 1)
{ {
jiffies_ms = (end.tv_sec - debug->create_time.tv_sec) * 1000 + (end.tv_nsec - debug->create_time.tv_nsec) / 1000000; jiffies_ms = (end.tv_sec - debug->create_time.tv_sec) * 1000 + (end.tv_nsec - debug->create_time.tv_nsec) / 1000000;
FS_operate(g_FP_instance.fs_handle, debug->fsid_latency, 0, FS_OP_SET, jiffies_ms); fieldstat_easy_histogram_record(g_FP_instance.fs_handle, __currect_thread_id, debug->fsid_latency, NULL, 0, jiffies_ms);
} }
return; return;
} }
void promise_failed(struct promise * p, enum e_future_error error, const char * what) void promise_failed(struct promise * p, enum e_future_error error, const char * what)
{ {
if(!g_FP_instance.no_stats) fp_stat_latency(&p->debug, 0); fp_stat_latency(&p->debug, 0);
if(!p->f.is_cancelled) if(!p->f.is_cancelled)
{ {
p->f.cb_failed(error, what, p->f.user); p->f.cb_failed(error, what, p->f.user);
@@ -291,7 +245,7 @@ void promise_failed(struct promise * p, enum e_future_error error, const char *
void promise_success(struct promise * p, void * result) void promise_success(struct promise * p, void * result)
{ {
if(!g_FP_instance.no_stats) fp_stat_latency(&p->debug, 1); fp_stat_latency(&p->debug, 1);
if(!p->f.is_cancelled) if(!p->f.is_cancelled)
{ {
p->f.cb_success(result, p->f.user); p->f.cb_success(result, p->f.user);

10
conf/tfe/future.conf
View File

@@ -1,10 +1,4 @@
[STAT] [STAT]
no_stats=0
statsd_server=127.0.0.1
statsd_port=8100
histogram_bins=0.50,0.80,0.9,0.95 histogram_bins=0.50,0.80,0.9,0.95
statsd_cycle=5 output_file=log/future.json
# FS_OUTPUT_STATSD=1, FS_OUTPUT_INFLUX_LINE=2 output_cycle=5
statsd_format=2
# printf diff Not available
# print_diff=1

14
conf/tfe/tfe.conf
View File

@@ -147,14 +147,8 @@ tcp_ttl_upstream=75
tcp_ttl_downstream=70 tcp_ttl_downstream=70
[stat] [stat]
statsd_server=127.0.0.1 output_file=log/tfe.json
statsd_port=8100 output_cycle=5
statsd_cycle=5
# 1:FS_OUTPUT_STATSD; 2:FS_OUTPUT_INFLUX_LINE
statsd_format=2
histogram_bins=0.5,0.8,0.9,0.95
statsd_set_prometheus_port=9001
statsd_set_prometheus_url_path=/tfe_prometheus
[traffic_mirror] [traffic_mirror]
enable=1 enable=1
@@ -163,7 +157,7 @@ device=eth4
type=1 type=1
default_vlan_id=2 default_vlan_id=2
table_info=resource/pangu/table_info_traffic_mirror.conf table_info=resource/pangu/table_info_traffic_mirror.conf
stat_file=log/traffic_mirror.status stat_file=log/traffic_mirror.json
app_symbol=tfe-mirror app_symbol=tfe-mirror
[traffic_steering] [traffic_steering]
@@ -197,7 +191,7 @@ stat_switch=1
perf_switch=1 perf_switch=1
table_info=resource/pangu/table_info.conf table_info=resource/pangu/table_info.conf
accept_path=/opt/tsg/etc/tsg_device_tag.json accept_path=/opt/tsg/etc/tsg_device_tag.json
stat_file=log/pangu_scan.fs2 stat_file=metrics/pangu_scan.json
effect_interval_s=1 effect_interval_s=1
deferred_load_on=0 deferred_load_on=0

2
platform/include/internal/proxy.h
View File

@@ -122,7 +122,7 @@ struct tfe_proxy
struct event * gcev; struct event * gcev;
void * logger; void * logger;
void * fs_handle; struct fieldstat_easy *fs_handle;
unsigned int nr_work_threads; unsigned int nr_work_threads;
struct tfe_thread_ctx * work_threads[TFE_THREAD_MAX]; struct tfe_thread_ctx * work_threads[TFE_THREAD_MAX];
int make_work_thread_sleep; int make_work_thread_sleep;

11
platform/include/internal/ssl_sess_cache.h
View File

@@ -4,6 +4,15 @@
#include <openssl/ssl.h> #include <openssl/ssl.h>
#include <tfe_stream.h> #include <tfe_stream.h>
struct sess_cache_stat
{
long long size;
long long query_cnt;
long long hit_cnt;
long long miss_cnt;
long long del_err;
};
struct sess_cache; struct sess_cache;
struct sess_cache * ssl_sess_cache_create(unsigned int slot_size, unsigned int expire_seconds, enum tfe_conn_dir served); struct sess_cache * ssl_sess_cache_create(unsigned int slot_size, unsigned int expire_seconds, enum tfe_conn_dir served);
void ssl_sess_cache_destroy(struct sess_cache * cache); void ssl_sess_cache_destroy(struct sess_cache * cache);
@@ -14,4 +23,4 @@ SSL_SESSION * up_session_get(struct sess_cache * cache, struct sockaddr * addr,
void down_session_set(struct sess_cache * cache, const SSL_SESSION * sess); void down_session_set(struct sess_cache * cache, const SSL_SESSION * sess);
void down_session_del(struct sess_cache * cache, const SSL_SESSION * sess); void down_session_del(struct sess_cache * cache, const SSL_SESSION * sess);
SSL_SESSION * down_session_get(struct sess_cache * cache, const unsigned char * id, int idlen); SSL_SESSION * down_session_get(struct sess_cache * cache, const unsigned char * id, int idlen);
void ssl_sess_cache_stat(struct sess_cache * cache, long long *size, long long* n_query,long long* n_hit); void ssl_sess_cache_stat(struct sess_cache *cache, struct sess_cache_stat *stat);

15
platform/src/key_keeper.cpp
View File

@@ -419,7 +419,7 @@ static void certstore_rpc_on_succ(void* result, void* user)
TFE_LOG_DEBUG(ctx->ref_keeper->logger, "Key keeper cache add key: %s", ctx->key); TFE_LOG_DEBUG(ctx->ref_keeper->logger, "Key keeper cache add key: %s", ctx->key);
} }
} }
ctx->ref_keeper->stat.new_issue++; ATOMIC_INC(&(ctx->ref_keeper->stat.new_issue));
promise_success(p, (void*)kyr); promise_success(p, (void*)kyr);
key_keeper_free_keyring((struct keyring*)kyr); key_keeper_free_keyring((struct keyring*)kyr);
} }
@@ -735,7 +735,7 @@ void key_keeper_async_ask(struct future * f, struct key_keeper * keeper, const c
ctx->key_len = len; ctx->key_len = len;
promise_set_ctx(p, (void*)ctx, key_keeper_promise_free_ctx); promise_set_ctx(p, (void*)ctx, key_keeper_promise_free_ctx);
long int cb_rtn = 0; long int cb_rtn = 0;
keeper->stat.ask_times++; ATOMIC_INC(&(keeper->stat.ask_times));
if(!keeper->no_cache) if(!keeper->no_cache)
{ {
char *tmp = tfe_strdup((const char *)ctx->key); char *tmp = tfe_strdup((const char *)ctx->key);
@@ -821,7 +821,7 @@ void key_keeper_async_ask(struct future * f, struct key_keeper * keeper, const c
} }
} }
promise_success(p, (void*)kyr); promise_success(p, (void*)kyr);
keeper->stat.new_issue++; ATOMIC_INC(&(keeper->stat.new_issue));
key_keeper_free_keyring((struct keyring*)kyr); key_keeper_free_keyring((struct keyring*)kyr);
} }
else else
@@ -837,10 +837,9 @@ void key_keeper_statistic(struct key_keeper *keeper, struct key_keeper_stat* res
{ {
if (!keeper->no_cache) if (!keeper->no_cache)
{ {
// pthread_rwlock_rdlock(&(keeper->rwlock)); result->cached_num = MESA_htable_get_elem_num(keeper->cert_cache);
keeper->stat.cached_num=MESA_htable_get_elem_num(keeper->cert_cache);
// pthread_rwlock_unlock(&(keeper->rwlock));
} }
*result = keeper->stat;
return; result->ask_times = ATOMIC_READ(&(keeper->stat.ask_times));
result->new_issue = ATOMIC_READ(&(keeper->stat.new_issue));
} }

74
platform/src/proxy.cpp
View File

@@ -30,7 +30,7 @@
#include <MESA/MESA_handle_logger.h> #include <MESA/MESA_handle_logger.h>
#include <MESA/MESA_prof_load.h> #include <MESA/MESA_prof_load.h>
#include <MESA/field_stat2.h> #include <fieldstat/fieldstat_easy.h>
#include <tfe_utils.h> #include <tfe_utils.h>
#include <tfe_future.h> #include <tfe_future.h>
@@ -300,16 +300,15 @@ static void __signal_handler_cb(evutil_socket_t fd, short what, void * arg)
static void __gc_handler_cb(evutil_socket_t fd, short what, void * arg) static void __gc_handler_cb(evutil_socket_t fd, short what, void * arg)
{ {
tfe_proxy *ctx = (tfe_proxy *)arg; tfe_proxy *ctx = (tfe_proxy *)arg;
int i = 0; for (int i = 0; i < TFE_STAT_MAX; i++)
for (i = 0; i < TFE_STAT_MAX; i++)
{ {
FS_operate(ctx->fs_handle, ctx->fs_id[i], 0, FS_OP_SET, ATOMIC_READ(&(ctx->stat_val[i]))); long long delta = ATOMIC_EXCHANGE(&(ctx->stat_val[i]), 0);
fieldstat_easy_counter_incrby(ctx->fs_handle, 0, ctx->fs_id[i], NULL, 0, delta);
} }
if (ctx->kni_v4_acceptor != NULL) if (ctx->kni_v4_acceptor != NULL)
packet_io_fs_dump(ctx->kni_v4_acceptor->packet_io_fs); packet_io_fs_dump(ctx->kni_v4_acceptor->packet_io_fs);
FS_passive_output(ctx->fs_handle);
timestamp_update(); timestamp_update();
return; return;
} }
@@ -500,52 +499,19 @@ static const char * __str_stat_spec_map[] =
int tfe_stat_init(struct tfe_proxy *proxy, const char *profile) int tfe_stat_init(struct tfe_proxy *proxy, const char *profile)
{ {
static const char * fieldstat_output = "log/tfe.fs2"; int output_cycle = 0;
static const char * app_name = "tfe3a"; char output_file[TFE_STRING_MAX] = {0};
MESA_load_profile_string_def(profile, "STAT", "output_file", output_file, sizeof(output_file), "log/tfe.fs4");
MESA_load_profile_int_def(profile, "STAT", "output_cycle", &(output_cycle), 5);
int value = 0, i = 0; proxy->fs_handle = fieldstat_easy_new(1, "tfe", NULL, 0);
screen_stat_handle_t fs_handle = NULL; fieldstat_easy_enable_auto_output(proxy->fs_handle, output_file, output_cycle);
char statsd_server_ip[TFE_SYMBOL_MAX]={0};
char histogram_bins[TFE_SYMBOL_MAX]={0};
int statsd_format=0;
int statsd_server_port=0;
MESA_load_profile_string_def(profile, "STAT", "statsd_server", statsd_server_ip,
sizeof(statsd_server_ip), "");
MESA_load_profile_int_def(profile, "STAT", "statsd_port", &(statsd_server_port), 0);
// FS_OUTPUT_STATSD=1, FS_OUTPUT_INFLUX_LINE=2
MESA_load_profile_int_def(profile, "STAT", "statsd_format", &(statsd_format), 1);
MESA_load_profile_string_def(profile, "STAT", "histogram_bins",
histogram_bins, sizeof(histogram_bins), "0.5,0.8,0.9,0.95");
if (statsd_format != 1 && statsd_format != 2) for (int i = 0; i < TFE_STAT_MAX; i++)
{ {
statsd_format = 1; proxy->fs_id[i] = fieldstat_easy_register_counter(proxy->fs_handle, __str_stat_spec_map[i]);
} }
fs_handle = FS_create_handle();
FS_set_para(fs_handle, OUTPUT_DEVICE, fieldstat_output, (int)strlen(fieldstat_output) + 1);
FS_set_para(fs_handle, APP_NAME, app_name, (int)strlen(app_name) + 1);
value = 1;
FS_set_para(fs_handle, OUTPUT_PROMETHEUS, &value, sizeof(value));
value = 1;
FS_set_para(fs_handle, PRINT_MODE, &value, sizeof(value));
value = 0;
FS_set_para(fs_handle, CREATE_THREAD, &value, sizeof(value));
if(strlen(statsd_server_ip)>0 && statsd_server_port!=0)
{
FS_set_para(fs_handle, STATS_SERVER_IP, statsd_server_ip, strlen(statsd_server_ip)+1);
FS_set_para(fs_handle, STATS_SERVER_PORT, &(statsd_server_port), sizeof(statsd_server_port));
FS_set_para(fs_handle, STATS_FORMAT, &statsd_format, sizeof(statsd_format));
}
FS_set_para(fs_handle, HISTOGRAM_GLOBAL_BINS, histogram_bins, strlen(histogram_bins)+1);
for (i = 0; i < TFE_STAT_MAX; i++)
{
proxy->fs_id[i] = FS_register(fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, __str_stat_spec_map[i]);
}
FS_start(fs_handle);
proxy->fs_handle = fs_handle;
return 0; return 0;
} }
@@ -651,7 +617,7 @@ int main(int argc, char * argv[])
/* PROXY INSTANCE */ /* PROXY INSTANCE */
g_default_proxy = ALLOC(struct tfe_proxy, 1); g_default_proxy = ALLOC(struct tfe_proxy, 1);
assert(g_default_proxy); assert(g_default_proxy);
strcpy(g_default_proxy->name, "tfe3a"); strcpy(g_default_proxy->name, "tfe");
g_default_proxy->breakpad = breakpad_init(main_profile, "system", g_default_logger, tfe_version()); g_default_proxy->breakpad = breakpad_init(main_profile, "system", g_default_logger, tfe_version());
CHECK_OR_EXIT(g_default_proxy->breakpad, "Failed at starting breakpad. Exit."); CHECK_OR_EXIT(g_default_proxy->breakpad, "Failed at starting breakpad. Exit.");
@@ -661,14 +627,6 @@ int main(int argc, char * argv[])
breakpad_segv_generate(); breakpad_segv_generate();
} }
int prometheus_port = 9001;
char prometheus_url_path[1024] = {0};
MESA_load_profile_int_def(main_profile, "STAT", "statsd_set_prometheus_port", &(prometheus_port), 9001);
MESA_load_profile_string_def(main_profile, "STAT", "statsd_set_prometheus_url_path", prometheus_url_path, sizeof(prometheus_url_path), "/tfe_prometheus");
FS_library_set_prometheus_port(prometheus_port);
FS_library_set_prometheus_url_path(prometheus_url_path);
FS_library_init();
future_promise_library_init(future_profile); future_promise_library_init(future_profile);
/* CONFIG */ /* CONFIG */
ret = tfe_proxy_config(g_default_proxy, main_profile); ret = tfe_proxy_config(g_default_proxy, main_profile);
@@ -706,9 +664,7 @@ int main(int argc, char * argv[])
CHECK_OR_EXIT(g_default_proxy->sev[i], "Failed at create signal event. Exit."); CHECK_OR_EXIT(g_default_proxy->sev[i], "Failed at create signal event. Exit.");
evsignal_add(g_default_proxy->sev[i], NULL); evsignal_add(g_default_proxy->sev[i], NULL);
} }
int statsd_cycle = 0; struct timeval gc_delay = {0, 500 * 1000}; // Microseconds, we set 500 miliseconds here.
MESA_load_profile_int_def(main_profile, "STAT", "statsd_cycle", &(statsd_cycle), 2);
struct timeval gc_delay = {statsd_cycle, 0};
evtimer_add(g_default_proxy->gcev, &gc_delay); evtimer_add(g_default_proxy->gcev, &gc_delay);
timestamp_update(); timestamp_update();
@@ -809,7 +765,7 @@ struct event_base * tfe_proxy_get_gc_evbase(void)
return g_default_proxy->evbase; return g_default_proxy->evbase;
} }
screen_stat_handle_t tfe_proxy_get_fs_handle(void) struct fieldstat_easy *tfe_proxy_get_fs_handle(void)
{ {
return g_default_proxy->fs_handle; return g_default_proxy->fs_handle;
} }

33
platform/src/ssl_service_cache.cpp
View File

@@ -43,16 +43,16 @@ static void ssl_svc_free_client_st(void * data)
struct ssl_service_cache* svc_cache=p->ref_svc_cache; struct ssl_service_cache* svc_cache=p->ref_svc_cache;
if(p->is_mutual_auth) if(p->is_mutual_auth)
{ {
svc_cache->stat.mutual_auth_cli_cnt--; ATOMIC_DEC(&(svc_cache->stat.mutual_auth_cli_cnt));
} }
if(p->suspect_pinning_count>=svc_cache->fail_as_cli_pinning_count) if(p->suspect_pinning_count>=svc_cache->fail_as_cli_pinning_count)
{ {
svc_cache->stat.pinning_cli_cnt--; ATOMIC_DEC(&(svc_cache->stat.pinning_cli_cnt));
} }
if (p->protocol_error_count >= svc_cache->fail_as_proto_err_count) if (p->protocol_error_count >= svc_cache->fail_as_proto_err_count)
{ {
svc_cache->stat.proto_err_cli_cnt--; ATOMIC_DEC(&(svc_cache->stat.proto_err_cli_cnt));
} }
free(p); free(p);
@@ -64,11 +64,11 @@ static void ssl_svc_free_server_st(void * data)
struct ssl_service_cache* svc_cache=p->ref_svc_cache; struct ssl_service_cache* svc_cache=p->ref_svc_cache;
if(p->is_ct) if(p->is_ct)
{ {
svc_cache->stat.ct_srv_cnt--; ATOMIC_DEC(&(svc_cache->stat.ct_srv_cnt));
} }
if(p->is_ev) if(p->is_ev)
{ {
svc_cache->stat.ev_srv_cnt--; ATOMIC_DEC(&(svc_cache->stat.ev_srv_cnt));
} }
free(p); free(p);
return; return;
@@ -79,7 +79,7 @@ static void ssl_svc_free_app_st(void *data)
struct ssl_service_cache *svc_cache = p->ref_svc_cache; struct ssl_service_cache *svc_cache = p->ref_svc_cache;
if (p->down_ssl_success_cnt > svc_cache->succ_as_app_not_pinning_count) if (p->down_ssl_success_cnt > svc_cache->succ_as_app_not_pinning_count)
{ {
svc_cache->stat.app_not_pinning_cnt--; ATOMIC_DEC(&(svc_cache->stat.app_not_pinning_cnt));
} }
free(p); free(p);
} }
@@ -189,7 +189,7 @@ static long cli_st_write_cb(void * data, const uchar * key, uint size, void * us
} }
if(cli_st->suspect_pinning_count==cache->fail_as_cli_pinning_count) if(cli_st->suspect_pinning_count==cache->fail_as_cli_pinning_count)
{ {
cache->stat.pinning_cli_cnt++; ATOMIC_INC(&(cache->stat.pinning_cli_cnt));
} }
} }
else if(status->cli_pinning_status==PINNING_ST_PINNING) else if(status->cli_pinning_status==PINNING_ST_PINNING)
@@ -201,12 +201,12 @@ static long cli_st_write_cb(void * data, const uchar * key, uint size, void * us
cli_st->protocol_error_count++; cli_st->protocol_error_count++;
if(cli_st->protocol_error_count==cache->fail_as_proto_err_count) if(cli_st->protocol_error_count==cache->fail_as_proto_err_count)
{ {
cache->stat.proto_err_cli_cnt++; ATOMIC_INC(&(cache->stat.proto_err_cli_cnt));
} }
} }
if(status->is_mutual_auth==1&&cli_st->is_mutual_auth==0) if(status->is_mutual_auth==1&&cli_st->is_mutual_auth==0)
{ {
cache->stat.mutual_auth_cli_cnt++; ATOMIC_INC(&(cache->stat.mutual_auth_cli_cnt));
cli_st->is_mutual_auth=1; cli_st->is_mutual_auth=1;
} }
cli_st->last_update_time=now; cli_st->last_update_time=now;
@@ -243,7 +243,7 @@ static long srv_st_write_cb(void * data, const uchar * key, uint size, void * us
if(status->is_ev==1&&srv_st->is_ev==0) if(status->is_ev==1&&srv_st->is_ev==0)
{ {
srv_st->is_ev=1; srv_st->is_ev=1;
cache->stat.ev_srv_cnt++; ATOMIC_INC(&(cache->stat.ev_srv_cnt));
} }
if(status->is_ev!=srv_st->is_ev) if(status->is_ev!=srv_st->is_ev)
{ {
@@ -252,7 +252,7 @@ static long srv_st_write_cb(void * data, const uchar * key, uint size, void * us
if(status->is_ct==1&&srv_st->is_ct==0) if(status->is_ct==1&&srv_st->is_ct==0)
{ {
srv_st->is_ct=1; srv_st->is_ct=1;
cache->stat.ct_srv_cnt++; ATOMIC_INC(&(cache->stat.ct_srv_cnt));
} }
if(status->is_ct!=srv_st->is_ct) if(status->is_ct!=srv_st->is_ct)
{ {
@@ -297,7 +297,7 @@ static long app_st_write_cb(void *data, const uchar *key, uint size, void *user_
} }
if (app_st->down_ssl_success_cnt > cache->succ_as_app_not_pinning_count) if (app_st->down_ssl_success_cnt > cache->succ_as_app_not_pinning_count)
{ {
cache->stat.app_not_pinning_cnt++; ATOMIC_INC(&(cache->stat.app_not_pinning_cnt));
} }
return 1; return 1;
} }
@@ -464,6 +464,11 @@ void ssl_service_cache_destroy(struct ssl_service_cache* cache)
} }
void ssl_service_cache_stat(struct ssl_service_cache *svc_cache, struct ssl_service_cache_statistics *result) void ssl_service_cache_stat(struct ssl_service_cache *svc_cache, struct ssl_service_cache_statistics *result)
{ {
*result=svc_cache->stat; result->pinning_cli_cnt = ATOMIC_READ(&(svc_cache->stat.pinning_cli_cnt));
return; result->mutual_auth_cli_cnt = ATOMIC_READ(&(svc_cache->stat.mutual_auth_cli_cnt));
result->proto_err_cli_cnt = ATOMIC_READ(&(svc_cache->stat.proto_err_cli_cnt));
result->ev_srv_cnt = ATOMIC_READ(&(svc_cache->stat.ev_srv_cnt));
result->ct_srv_cnt = ATOMIC_READ(&(svc_cache->stat.ct_srv_cnt));
result->app_not_pinning_cnt = ATOMIC_READ(&(svc_cache->stat.app_not_pinning_cnt));
result->trusted_cert_cnt = ATOMIC_READ(&(svc_cache->stat.trusted_cert_cnt));
} }

26
platform/src/ssl_sess_cache.cpp
View File

@@ -5,7 +5,7 @@
#include <tfe_utils.h> #include <tfe_utils.h>
#include <MESA/MESA_htable.h> #include <MESA/MESA_htable.h>
#include <MESA/field_stat2.h> #include <fieldstat/fieldstat_easy.h>
#define SESS_CACHE_NOT_FOUND -1 #define SESS_CACHE_NOT_FOUND -1
#define SESS_CACHE_FOUND 0 #define SESS_CACHE_FOUND 0
@@ -35,7 +35,7 @@ struct sess_cache
{ {
enum tfe_conn_dir served_for; enum tfe_conn_dir served_for;
MESA_htable_handle hash; MESA_htable_handle hash;
long long hit_cnt, miss_cnt, del_err; struct sess_cache_stat stat;
}; };
static void ssl_sess_free_serialized(void * data) static void ssl_sess_free_serialized(void * data)
@@ -231,12 +231,12 @@ SSL_SESSION * up_session_get(struct sess_cache * cache, struct sockaddr * addr,
key = NULL; key = NULL;
if (cb_ret == SESS_CACHE_FOUND && args.version>=min_ver && args.version<=max_ver) if (cb_ret == SESS_CACHE_FOUND && args.version>=min_ver && args.version<=max_ver)
{ {
ATOMIC_INC(&(cache->hit_cnt)); ATOMIC_INC(&(cache->stat.hit_cnt));
return args.sess; return args.sess;
} }
else else
{ {
ATOMIC_INC(&(cache->miss_cnt)); ATOMIC_INC(&(cache->stat.miss_cnt));
return NULL; return NULL;
} }
} }
@@ -275,12 +275,12 @@ SSL_SESSION * down_session_get(struct sess_cache * cache, const unsigned char *
MESA_htable_search_cb(cache->hash, id, (unsigned int) idlen, sess_cache_get_cb, &result, &cb_ret); MESA_htable_search_cb(cache->hash, id, (unsigned int) idlen, sess_cache_get_cb, &result, &cb_ret);
if (cb_ret == SESS_CACHE_FOUND) if (cb_ret == SESS_CACHE_FOUND)
{ {
ATOMIC_INC(&(cache->hit_cnt)); ATOMIC_INC(&(cache->stat.hit_cnt));
return result.sess; return result.sess;
} }
else else
{ {
ATOMIC_INC(&(cache->miss_cnt)); ATOMIC_INC(&(cache->stat.miss_cnt));
return NULL; return NULL;
} }
} }
@@ -293,7 +293,7 @@ void down_session_del(struct sess_cache * cache, const SSL_SESSION * sess)
int ret = MESA_htable_del(cache->hash, id, len, NULL); int ret = MESA_htable_del(cache->hash, id, len, NULL);
if (ret != MESA_HTABLE_RET_OK) if (ret != MESA_HTABLE_RET_OK)
{ {
ATOMIC_INC(&(cache->del_err)); ATOMIC_INC(&(cache->stat.del_err));
} }
return; return;
} }
@@ -337,11 +337,11 @@ void ssl_sess_cache_destroy(struct sess_cache * cache)
free(cache); free(cache);
return; return;
} }
void ssl_sess_cache_stat(struct sess_cache * cache, long long *size, long long *n_query, long long* n_hit) void ssl_sess_cache_stat(struct sess_cache *cache, struct sess_cache_stat *stat)
{ {
*size=MESA_htable_get_elem_num(cache->hash); stat->size = MESA_htable_get_elem_num(cache->hash);
*n_hit=cache->hit_cnt; stat->hit_cnt = ATOMIC_READ(&(cache->stat.hit_cnt));
*n_query=cache->hit_cnt+cache->miss_cnt; stat->miss_cnt = ATOMIC_READ(&(cache->stat.miss_cnt));
return; stat->del_err = ATOMIC_READ(&(cache->stat.del_err));
stat->query_cnt = stat->hit_cnt + stat->miss_cnt;
} }

110
platform/src/ssl_stream.cpp
View File

@@ -173,7 +173,7 @@ struct ssl_mgr
FILE* fp_master_key; FILE* fp_master_key;
void * logger; void * logger;
screen_stat_handle_t fs_handle; struct fieldstat_easy *fs_handle;
long long stat_val[SSL_STAT_MAX]; long long stat_val[SSL_STAT_MAX];
int fs_id[SSL_STAT_MAX]; int fs_id[SSL_STAT_MAX];
}; };
@@ -350,34 +350,52 @@ const char* ssl_stream_get_error_string(enum ssl_stream_error error)
/* /*
* Garbage collection handler. * Garbage collection handler.
*/ */
static void static void ssl_stream_gc_cb(evutil_socket_t fd, short what, void *arg)
ssl_stream_gc_cb(evutil_socket_t fd, short what, void * arg)
{ {
struct ssl_mgr *mgr = (struct ssl_mgr *)arg; struct ssl_mgr *mgr = (struct ssl_mgr *)arg;
int i=0;
if (!mgr->no_sesscache) if (!mgr->no_sesscache)
{ {
ssl_sess_cache_stat(mgr->up_sess_cache, &(mgr->stat_val[SSL_UP_CACHE_SZ]), &(mgr->stat_val[SSL_UP_CACHE_QUERY]), &(mgr->stat_val[SSL_UP_CACHE_HIT])); struct sess_cache_stat usc_curr_stat = {0};
ssl_sess_cache_stat(mgr->down_sess_cache, &(mgr->stat_val[SSL_DOWN_CACHE_SZ]), &(mgr->stat_val[SSL_DOWN_CACHE_QUERY]), &(mgr->stat_val[SSL_DOWN_CACHE_HIT])); struct sess_cache_stat dsc_curr_stat = {0};
} static struct sess_cache_stat usc_last_stat = {0};
struct key_keeper_stat keeper_stat = { 0 }; static struct sess_cache_stat dsc_last_stat = {0};
key_keeper_statistic(mgr->key_keeper, &keeper_stat);
mgr->stat_val[KEY_KEEPER_ASK]=keeper_stat.ask_times;
mgr->stat_val[KEY_KEEPER_ISSUE]=keeper_stat.new_issue;
mgr->stat_val[KEY_KEEPER_CACHE_SIZE]=keeper_stat.cached_num;
struct ssl_service_cache_statistics svc_stat; ssl_sess_cache_stat(mgr->up_sess_cache, &usc_curr_stat);
memset(&svc_stat, 0, sizeof(svc_stat)); mgr->stat_val[SSL_UP_CACHE_SZ] = usc_curr_stat.size - usc_last_stat.size;
ssl_service_cache_stat(mgr->svc_cache, &svc_stat); mgr->stat_val[SSL_UP_CACHE_QUERY] = usc_curr_stat.query_cnt - usc_last_stat.query_cnt;
mgr->stat_val[SSL_SVC_PINNING]=svc_stat.pinning_cli_cnt; mgr->stat_val[SSL_UP_CACHE_HIT] = usc_curr_stat.hit_cnt- usc_last_stat.hit_cnt;
mgr->stat_val[SSL_SVC_MAUTH]=svc_stat.mutual_auth_cli_cnt; usc_last_stat = usc_curr_stat;
mgr->stat_val[SSL_SVC_CT_CERT]=svc_stat.ct_srv_cnt;
mgr->stat_val[SSL_SVC_EV_CERT]=svc_stat.ev_srv_cnt; ssl_sess_cache_stat(mgr->down_sess_cache, &dsc_curr_stat);
mgr->stat_val[SSL_SVC_APP_NOT_PINNING]=svc_stat.app_not_pinning_cnt; mgr->stat_val[SSL_DOWN_CACHE_SZ] = dsc_curr_stat.size - dsc_last_stat.size;
mgr->stat_val[SSL_SVC_TRUSTED_CERT]=svc_stat.trusted_cert_cnt; mgr->stat_val[SSL_DOWN_CACHE_QUERY] = dsc_curr_stat.query_cnt - dsc_last_stat.query_cnt;
for(i=0;i<SSL_STAT_MAX;i++) mgr->stat_val[SSL_DOWN_CACHE_HIT] = dsc_curr_stat.hit_cnt - dsc_last_stat.hit_cnt;
dsc_last_stat = dsc_curr_stat;
}
struct key_keeper_stat keeper_curr_stat = {0};
static struct key_keeper_stat keeper_last_stat = {0};
key_keeper_statistic(mgr->key_keeper, &keeper_curr_stat);
mgr->stat_val[KEY_KEEPER_ASK] = keeper_curr_stat.ask_times - keeper_last_stat.ask_times;
mgr->stat_val[KEY_KEEPER_ISSUE] = keeper_curr_stat.new_issue - keeper_last_stat.new_issue;
mgr->stat_val[KEY_KEEPER_CACHE_SIZE] = keeper_curr_stat.cached_num - keeper_last_stat.cached_num;
keeper_last_stat = keeper_curr_stat;
struct ssl_service_cache_statistics svc_curr_stat = {0};
static struct ssl_service_cache_statistics svc_last_stat = {0};
ssl_service_cache_stat(mgr->svc_cache, &svc_curr_stat);
mgr->stat_val[SSL_SVC_PINNING] = svc_curr_stat.pinning_cli_cnt - svc_last_stat.pinning_cli_cnt;
mgr->stat_val[SSL_SVC_MAUTH] = svc_curr_stat.mutual_auth_cli_cnt - svc_last_stat.mutual_auth_cli_cnt;
mgr->stat_val[SSL_SVC_CT_CERT] = svc_curr_stat.ct_srv_cnt - svc_last_stat.ct_srv_cnt;
mgr->stat_val[SSL_SVC_EV_CERT] = svc_curr_stat.ev_srv_cnt - svc_last_stat.ev_srv_cnt;
mgr->stat_val[SSL_SVC_APP_NOT_PINNING] = svc_curr_stat.app_not_pinning_cnt - svc_last_stat.app_not_pinning_cnt;
mgr->stat_val[SSL_SVC_TRUSTED_CERT] = svc_curr_stat.trusted_cert_cnt - svc_last_stat.trusted_cert_cnt;
svc_last_stat = svc_curr_stat;
for (int i = 0; i < SSL_STAT_MAX; i++)
{ {
FS_operate(mgr->fs_handle, mgr->fs_id[i], 0, FS_OP_SET, ATOMIC_READ(&(mgr->stat_val[i]))); long long delta = ATOMIC_EXCHANGE(&(mgr->stat_val[i]), 0);
fieldstat_easy_counter_incrby(mgr->fs_handle, 0, mgr->fs_id[i], NULL, 0, delta);
} }
if (mgr->log_master_key && mgr->fp_master_key) if (mgr->log_master_key && mgr->fp_master_key)
{ {
@@ -434,58 +452,14 @@ void ssl_stat_init(struct ssl_mgr * mgr)
spec[SSL_SVC_TRUSTED_CERT]="trusted_cert_nums"; spec[SSL_SVC_TRUSTED_CERT]="trusted_cert_nums";
for (i = 0; i < SSL_STAT_MAX; i++) for (i = 0; i < SSL_STAT_MAX; i++)
{ {
if (spec[i] != NULL) if (spec[i] != NULL)
{ {
mgr->fs_id[i]=FS_register(mgr->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT,spec[i]); mgr->fs_id[i] = fieldstat_easy_register_counter(mgr->fs_handle, spec[i]);
} }
} }
int value=mgr->fs_id[SSL_UP_CACHE_HIT];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
value=mgr->fs_id[SSL_UP_CACHE_QUERY];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
FS_register_ratio(mgr->fs_handle,
mgr->fs_id[SSL_UP_CACHE_HIT],
mgr->fs_id[SSL_UP_CACHE_QUERY],
1,
FS_STYLE_STATUS,
FS_CALC_CURRENT,
"usess_hit");
value=mgr->fs_id[SSL_DOWN_CACHE_HIT];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
value=mgr->fs_id[SSL_DOWN_CACHE_QUERY];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
FS_register_ratio(mgr->fs_handle,
mgr->fs_id[SSL_DOWN_CACHE_HIT],
mgr->fs_id[SSL_DOWN_CACHE_QUERY],
1,
FS_STYLE_STATUS,
FS_CALC_CURRENT,
"dsess_hit");
if(!mgr->no_sessticket)
{
value=mgr->fs_id[SSL_DOWN_TIKCET_QUERY];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
value=mgr->fs_id[SSL_DOWN_TICKET_REUSE];
FS_set_para(mgr->fs_handle, ID_INVISBLE, &value, sizeof(value));
FS_register_ratio(mgr->fs_handle,
mgr->fs_id[SSL_DOWN_TICKET_REUSE],
mgr->fs_id[SSL_DOWN_TIKCET_QUERY],
1,
FS_STYLE_STATUS,
FS_CALC_CURRENT,
"dtkt_hit");
}
struct timeval gc_delay = {0, 500*1000}; //Microseconds, we set 500 miliseconds here. struct timeval gc_delay = {0, 500*1000}; //Microseconds, we set 500 miliseconds here.
mgr->gcev = event_new(mgr->ev_base_gc, -1, EV_PERSIST, ssl_stream_gc_cb, mgr); mgr->gcev = event_new(mgr->ev_base_gc, -1, EV_PERSIST, ssl_stream_gc_cb, mgr);
evtimer_add(mgr->gcev, &gc_delay); evtimer_add(mgr->gcev, &gc_delay);

9
plugin/business/doh/src/doh.cpp
View File

@@ -391,11 +391,10 @@ static void doh_maat_scan(const struct tfe_stream *stream, const struct tfe_http
static void doh_gc_cb(evutil_socket_t fd, short what, void *arg) static void doh_gc_cb(evutil_socket_t fd, short what, void *arg)
{ {
int i = 0; for (int i = 0; i < DOH_STAT_MAX; i++)
for (i = 0; i < DOH_STAT_MAX; i++)
{ {
FS_operate(g_doh_conf->fs_handle, g_doh_conf->fs_id[i], 0, FS_OP_SET, ATOMIC_READ(&(g_doh_conf->stat_val[i]))); long long delta = ATOMIC_EXCHANGE(&(g_doh_conf->stat_val[i]), 0);
fieldstat_easy_counter_incrby(g_doh_conf->fs_handle, 0, g_doh_conf->fs_id[i], NULL, 0, delta);
} }
} }
@@ -413,7 +412,7 @@ static int doh_field_init()
{ {
if (spec[i] != NULL) if (spec[i] != NULL)
{ {
g_doh_conf->fs_id[i] = FS_register(g_doh_conf->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, spec[i]); g_doh_conf->fs_id[i] = fieldstat_easy_register_counter(g_doh_conf->fs_handle, spec[i]);
} }
} }
g_doh_conf->gcev = event_new(g_doh_conf->gc_evbase, -1, EV_PERSIST, doh_gc_cb, NULL); g_doh_conf->gcev = event_new(g_doh_conf->gc_evbase, -1, EV_PERSIST, doh_gc_cb, NULL);

2
plugin/business/doh/src/pub.h
View File

@@ -56,7 +56,7 @@ struct doh_conf
long long stat_val[DOH_STAT_MAX]; long long stat_val[DOH_STAT_MAX];
struct event *gcev; struct event *gcev;
struct event_base *gc_evbase; struct event_base *gc_evbase;
screen_stat_handle_t fs_handle; struct fieldstat_easy *fs_handle;
struct maat *maat; struct maat *maat;
}; };

2
plugin/business/traffic-mirror/include/traffic_mirror.h
View File

@@ -32,7 +32,7 @@ enum
struct traffic_mirror_stat struct traffic_mirror_stat
{ {
screen_stat_handle_t fs_handle; struct fieldstat_easy *fs_handle;
uint64_t stat_idx[TRAFFIC_MIRR_STAT_MAX]; uint64_t stat_idx[TRAFFIC_MIRR_STAT_MAX];
uint64_t stat_val[TRAFFIC_MIRR_STAT_MAX]; uint64_t stat_val[TRAFFIC_MIRR_STAT_MAX];

7
plugin/business/traffic-mirror/src/entry.cpp
View File

@@ -28,7 +28,8 @@ static void stat_output_cb(evutil_socket_t fd, short what, void *arg)
struct traffic_mirror_stat *handle = (struct traffic_mirror_stat *)arg; struct traffic_mirror_stat *handle = (struct traffic_mirror_stat *)arg;
for (int i = 0; i < TRAFFIC_MIRR_STAT_MAX; i++) for (int i = 0; i < TRAFFIC_MIRR_STAT_MAX; i++)
{ {
FS_operate(handle->fs_handle, handle->stat_idx[i], 0, FS_OP_SET, ATOMIC_READ(&(handle->stat_val[i]))); long long delta = ATOMIC_EXCHANGE(&(handle->stat_val[i]), 0);
fieldstat_easy_counter_incrby(handle->fs_handle, 0, handle->stat_idx[i], NULL, 0, delta);
} }
} }
@@ -40,7 +41,6 @@ struct traffic_mirror_stat *traffic_mirror_stat_new()
return NULL; return NULL;
} }
struct timeval gc_delay = {5, 0};
const char *stat_name[TRAFFIC_MIRR_STAT_MAX] = { 0 }; const char *stat_name[TRAFFIC_MIRR_STAT_MAX] = { 0 };
stat_name[TRAFFIC_MIRR_STAT_SUCC_BYTES] = "mirr_succ_B"; stat_name[TRAFFIC_MIRR_STAT_SUCC_BYTES] = "mirr_succ_B";
stat_name[TRAFFIC_MIRR_STAT_SUCC_PKTS] = "mirr_succ_P"; stat_name[TRAFFIC_MIRR_STAT_SUCC_PKTS] = "mirr_succ_P";
@@ -50,9 +50,10 @@ struct traffic_mirror_stat *traffic_mirror_stat_new()
handle->evbase = tfe_proxy_get_gc_evbase(); handle->evbase = tfe_proxy_get_gc_evbase();
for (int i = 0; i < TRAFFIC_MIRR_STAT_MAX; i++) for (int i = 0; i < TRAFFIC_MIRR_STAT_MAX; i++)
{ {
handle->stat_idx[i] = FS_register(handle->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, stat_name[i]); handle->stat_idx[i] = fieldstat_easy_register_counter(handle->fs_handle, stat_name[i]);
} }
handle->ev = event_new(handle->evbase, -1, EV_PERSIST, stat_output_cb, handle); handle->ev = event_new(handle->evbase, -1, EV_PERSIST, stat_output_cb, handle);
struct timeval gc_delay = {0, 500 * 1000}; // Microseconds, we set 500 miliseconds here.
evtimer_add(handle->ev, &gc_delay); evtimer_add(handle->ev, &gc_delay);
return handle; return handle;

2
plugin/business/traffic-mirror/src/rebuild.cpp
View File

@@ -6,6 +6,8 @@
#include <marsio.h> #include <marsio.h>
#include <netinet/ip.h> #include <netinet/ip.h>
#include <netinet/ip6.h> #include <netinet/ip6.h>
#define __FAVOR_BSD 1
#include <netinet/tcp.h>
struct traffic_mirror_rebuild struct traffic_mirror_rebuild
{ {

12
plugin/business/tsg-http/src/tsg_http.cpp
View File

@@ -152,7 +152,7 @@ struct tsg_proxy_rt
int plolicy_table_id[POLICY_PROFILE_TABLE_MAX]; int plolicy_table_id[POLICY_PROFILE_TABLE_MAX];
ctemplate::Template * tpl_403, * tpl_404, * tpl_451; ctemplate::Template * tpl_403, * tpl_404, * tpl_451;
screen_stat_handle_t fs_handle; struct fieldstat_easy *fs_handle;
long long stat_val[__PX_STAT_MAX]; long long stat_val[__PX_STAT_MAX];
int fs_id[__PX_STAT_MAX]; int fs_id[__PX_STAT_MAX];
struct event_base* gc_evbase; struct event_base* gc_evbase;
@@ -169,13 +169,11 @@ struct tsg_proxy_rt * g_proxy_rt;
static void proxy_http_gc_cb(evutil_socket_t fd, short what, void *arg) static void proxy_http_gc_cb(evutil_socket_t fd, short what, void *arg)
{ {
int i=0; for (int i = 0; i < __PX_STAT_MAX; i++)
for(i=0;i<__PX_STAT_MAX;i++)
{ {
FS_operate(g_proxy_rt->fs_handle, g_proxy_rt->fs_id[i], 0, FS_OP_SET, ATOMIC_READ(&(g_proxy_rt->stat_val[i]))); long long delta = ATOMIC_EXCHANGE(&(g_proxy_rt->stat_val[i]), 0);
fieldstat_easy_counter_incrby(g_proxy_rt->fs_handle, 0, g_proxy_rt->fs_id[i], NULL, 0, delta);
} }
return;
} }
static void proxy_http_stat_init(struct tsg_proxy_rt * pangu_runtime) static void proxy_http_stat_init(struct tsg_proxy_rt * pangu_runtime)
@@ -202,7 +200,7 @@ static void proxy_http_stat_init(struct tsg_proxy_rt * pangu_runtime)
{ {
if (spec[i] != NULL) if (spec[i] != NULL)
{ {
pangu_runtime->fs_id[i]=FS_register(pangu_runtime->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, spec[i]); pangu_runtime->fs_id[i] = fieldstat_easy_register_counter(pangu_runtime->fs_handle, spec[i]);
} }
} }
g_proxy_rt->gcev = event_new(pangu_runtime->gc_evbase, -1, EV_PERSIST, proxy_http_gc_cb, NULL); g_proxy_rt->gcev = event_new(pangu_runtime->gc_evbase, -1, EV_PERSIST, proxy_http_gc_cb, NULL);