diff --git a/src/session/session.cpp b/src/session/session.cpp
index 0b7f7c3..b439e73 100644
--- a/src/session/session.cpp
+++ b/src/session/session.cpp
@@ -200,7 +200,8 @@ struct tcp_segment *session_get_tcp_segment(struct session *sess)
         struct tcp_segment *seg = tcp_reassembly_pop(half->assembler);
         if (seg)
         {
-            half->nr_seg_reorded++;
+            sess->mgr_stat->nr_tcp_seg_reorded++;
+            half->nr_tcp_seg_reorded++;
         }
         return seg;
     }
@@ -231,7 +232,8 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
     }
     else
     {
-        half->nr_seg_released++;
+        sess->mgr_stat->nr_tcp_seg_released++;
+        half->nr_tcp_seg_released++;
         tcp_segment_free(seg);
     }
 }
@@ -431,15 +433,15 @@ void tcp_half_dump(const struct tcp_half *half)
     {
         used += snprintf(buffer + used, sizeof(buffer) - used, "RST ");
     }
-    printf("           flags           : %s\n", buffer);
-    printf("           nr_seg_received : %lu\n", half->nr_seg_received);
-    printf("           nr_seg_expired  : %lu\n", half->nr_seg_expired);
-    printf("           nr_seg_overlap  : %lu\n", half->nr_seg_overlap);
-    printf("           nr_seg_no_space : %lu\n", half->nr_seg_no_space);
-    printf("           nr_seg_inorder  : %lu\n", half->nr_seg_inorder);
-    printf("           nr_seg_reorded  : %lu\n", half->nr_seg_reorded);
-    printf("           nr_seg_buffered : %lu\n", half->nr_seg_buffered);
-    printf("           nr_seg_released : %lu\n", half->nr_seg_released);
+    printf("           flags               : %s\n", buffer);
+    printf("           nr_tcp_seg_received : %lu\n", half->nr_tcp_seg_received);
+    printf("           nr_tcp_seg_expired  : %lu\n", half->nr_tcp_seg_expired);
+    printf("           nr_tcp_seg_overlap  : %lu\n", half->nr_tcp_seg_overlap);
+    printf("           nr_tcp_seg_no_space : %lu\n", half->nr_tcp_seg_no_space);
+    printf("           nr_tcp_seg_inorder  : %lu\n", half->nr_tcp_seg_inorder);
+    printf("           nr_tcp_seg_reorded  : %lu\n", half->nr_tcp_seg_reorded);
+    printf("           nr_tcp_seg_buffered : %lu\n", half->nr_tcp_seg_buffered);
+    printf("           nr_tcp_seg_released : %lu\n", half->nr_tcp_seg_released);
 }
 
 void session_dump(struct session *sess)
diff --git a/src/session/session.h b/src/session/session.h
index 8d96d05..9600c99 100644
--- a/src/session/session.h
+++ b/src/session/session.h
@@ -14,6 +14,7 @@ extern "C"
 #include "timeout.h"
 #include "uthash.h"
 #include "tcp_reassembly.h"
+#include "session_manager.h"
 
 #define EX_DATA_MAX_COUNT 16
 
@@ -80,16 +81,16 @@ struct tcp_half
     struct tcp_reassembly *assembler;
     struct tcp_segment order;
 
-    uint64_t nr_seg_received;
-    uint64_t nr_seg_expired;
-    uint64_t nr_seg_overlap; //(retransmission)
-    uint64_t nr_seg_no_space;
+    uint64_t nr_tcp_seg_received;
+    uint64_t nr_tcp_seg_expired;
+    uint64_t nr_tcp_seg_overlap; //(retransmission)
+    uint64_t nr_tcp_seg_no_space;
 
-    uint64_t nr_seg_inorder;
-    uint64_t nr_seg_reorded;
+    uint64_t nr_tcp_seg_inorder;
+    uint64_t nr_tcp_seg_reorded;
 
-    uint64_t nr_seg_buffered;
-    uint64_t nr_seg_released;
+    uint64_t nr_tcp_seg_buffered;
+    uint64_t nr_tcp_seg_released;
 
     uint32_t seq;
     uint32_t ack;
@@ -130,6 +131,7 @@ struct session
     void *user_data;
 
     struct tcp_pcb tcp_pcb;
+    struct session_manager_stat *mgr_stat;
 };
 
 /******************************************************************************
diff --git a/src/session/session_manager.cpp b/src/session/session_manager.cpp
index ee9bc4e..a5d18e6 100644
--- a/src/session/session_manager.cpp
+++ b/src/session/session_manager.cpp
@@ -30,6 +30,80 @@ struct session_manager
 
 #define EVICTE_SESSION_BURST (RX_BURST_MAX)
 
+/******************************************************************************
+ * Stat
+ ******************************************************************************/
+
+#define NR_SESS_STAT_INC(stat, state, type)        \
+     {                                             \
+          switch ((state))                         \
+          {                                        \
+          case SESSION_STATE_OPENING:              \
+               (stat)->nr_##type##_sess_opening++; \
+               break;                              \
+          case SESSION_STATE_ACTIVE:               \
+               (stat)->nr_##type##_sess_active++;  \
+               break;                              \
+          case SESSION_STATE_CLOSING:              \
+               (stat)->nr_##type##_sess_closing++; \
+               break;                              \
+          case SESSION_STATE_DISCARD:              \
+               (stat)->nr_##type##_sess_discard++; \
+               break;                              \
+          case SESSION_STATE_CLOSED:               \
+               (stat)->nr_##type##_sess_closed++;  \
+               break;                              \
+          default:                                 \
+               break;                              \
+          }                                        \
+     }
+
+#define NR_SESS_STAT_DEC(stat, state, type)        \
+     {                                             \
+          switch ((state))                         \
+          {                                        \
+          case SESSION_STATE_OPENING:              \
+               (stat)->nr_##type##_sess_opening--; \
+               break;                              \
+          case SESSION_STATE_ACTIVE:               \
+               (stat)->nr_##type##_sess_active--;  \
+               break;                              \
+          case SESSION_STATE_CLOSING:              \
+               (stat)->nr_##type##_sess_closing--; \
+               break;                              \
+          case SESSION_STATE_DISCARD:              \
+               (stat)->nr_##type##_sess_discard--; \
+               break;                              \
+          case SESSION_STATE_CLOSED:               \
+               (stat)->nr_##type##_sess_closed--;  \
+               break;                              \
+          default:                                 \
+               break;                              \
+          }                                        \
+     }
+
+#define NR_SESS_STAT_UPDATE(stat, curr, next, type) \
+     {                                              \
+          if (curr != next)                         \
+          {                                         \
+               NR_SESS_STAT_DEC(stat, curr, type);  \
+               NR_SESS_STAT_INC(stat, next, type);  \
+          }                                         \
+     }
+
+#define NR_TCP_SESS_STAT_INC(stat, state) NR_SESS_STAT_INC(stat, state, tcp)
+#define NR_UDP_SESS_STAT_INC(stat, state) NR_SESS_STAT_INC(stat, state, udp)
+
+#define NR_TCP_SESS_STAT_DEC(stat, state) NR_SESS_STAT_DEC(stat, state, tcp)
+#define NR_UDP_SESS_STAT_DEC(stat, state) NR_SESS_STAT_DEC(stat, state, udp)
+
+#define NR_TCP_SESS_STAT_UPDATE(stat, curr, next) NR_SESS_STAT_UPDATE(stat, curr, next, tcp)
+#define NR_UDP_SESS_STAT_UPDATE(stat, curr, next) NR_SESS_STAT_UPDATE(stat, curr, next, udp)
+
+/******************************************************************************
+ * Options
+ ******************************************************************************/
+
 static int check_options(const struct session_manager_options *opts)
 {
      if (opts == NULL)
@@ -155,6 +229,10 @@ static int check_options(const struct session_manager_options *opts)
      return 0;
 }
 
+/******************************************************************************
+ * TCP protocol control block
+ ******************************************************************************/
+
 /*
  * The next routines deal with comparing 32 bit unsigned ints
  * and worry about wraparound (automatic with unsigned arithmetic).
@@ -193,7 +271,7 @@ static int tcp_pcb_init(struct tcp_pcb *pcb, uint8_t tcp_reassembly_enable, uint
      return 0;
 }
 
-static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const struct pkt_layer *tcp_layer, uint64_t now)
+static void tcp_pcb_update(struct session_manager_stat *stat, struct tcp_pcb *pcb, enum session_dir dir, const struct pkt_layer *tcp_layer, uint64_t now)
 {
      struct tcp_segment *seg;
      struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
@@ -208,8 +286,10 @@ static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const stru
      {
           if (tcp_layer->pld_len)
           {
-               half->nr_seg_received++;
-               half->nr_seg_inorder++;
+               half->nr_tcp_seg_received++;
+               half->nr_tcp_seg_inorder++;
+               stat->nr_tcp_seg_received++;
+               stat->nr_tcp_seg_inorder++;
                half->order.data = tcp_layer->pld_ptr;
                half->order.len = tcp_layer->pld_len;
           }
@@ -224,42 +304,51 @@ static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const stru
      seg = tcp_reassembly_expire(half->assembler, now);
      if (seg)
      {
-          half->nr_seg_expired++;
-          half->nr_seg_released++;
+          half->nr_tcp_seg_expired++;
+          half->nr_tcp_seg_released++;
+          stat->nr_tcp_seg_expired++;
+          stat->nr_tcp_seg_released++;
           tcp_segment_free(seg);
      }
 
      if (tcp_layer->pld_len)
      {
-          half->nr_seg_received++;
+          half->nr_tcp_seg_received++;
+          stat->nr_tcp_seg_received++;
 
           uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler);
           if (half->seq == rcv_nxt)
           {
-               half->nr_seg_inorder++;
+               half->nr_tcp_seg_inorder++;
+               stat->nr_tcp_seg_inorder++;
+
                half->order.data = tcp_layer->pld_ptr;
                half->order.len = tcp_layer->pld_len;
                tcp_reassembly_inc_recv_next(half->assembler, tcp_layer->pld_len);
           }
           else if (before(half->seq, rcv_nxt))
           {
-               // TODO add metric (overlap)
-               half->nr_seg_overlap++;
+               half->nr_tcp_seg_overlap++;
+               stat->nr_tcp_seg_overlap++;
           }
           else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, tcp_layer->pld_len)))
           {
                switch (tcp_reassembly_push(half->assembler, seg, now))
                {
                case -1:
-                    half->nr_seg_no_space++;
+                    half->nr_tcp_seg_no_space++;
+                    stat->nr_tcp_seg_no_space++;
                     tcp_segment_free(seg);
                     break;
                case 0:
-                    half->nr_seg_buffered++;
+                    half->nr_tcp_seg_buffered++;
+                    stat->nr_tcp_seg_buffered++;
                     break;
                case 1:
-                    half->nr_seg_buffered++;
-                    half->nr_seg_overlap++;
+                    half->nr_tcp_seg_buffered++;
+                    half->nr_tcp_seg_overlap++;
+                    stat->nr_tcp_seg_buffered++;
+                    stat->nr_tcp_seg_overlap++;
                     break;
                default:
                     assert(0);
@@ -268,86 +357,12 @@ static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const stru
           }
           else
           {
-               half->nr_seg_no_space++;
+               half->nr_tcp_seg_no_space++;
+               stat->nr_tcp_seg_no_space++;
           }
      }
 }
 
-/******************************************************************************
- * Stat
- ******************************************************************************/
-
-static void session_stat_inc(struct session_stat *stat, enum session_state state)
-{
-     switch (state)
-     {
-     case SESSION_STATE_INIT:
-          stat->nr_sess_init++;
-          break;
-     case SESSION_STATE_OPENING:
-          stat->nr_sess_opening++;
-          break;
-     case SESSION_STATE_ACTIVE:
-          stat->nr_sess_active++;
-          break;
-     case SESSION_STATE_CLOSING:
-          stat->nr_sess_closing++;
-          break;
-     case SESSION_STATE_DISCARD:
-          stat->nr_sess_discard++;
-          break;
-     case SESSION_STATE_CLOSED:
-          stat->nr_sess_closed++;
-          break;
-     default:
-          break;
-     }
-}
-
-static void session_stat_dec(struct session_stat *stat, enum session_state state)
-{
-     switch (state)
-     {
-     case SESSION_STATE_INIT:
-          stat->nr_sess_init--;
-          break;
-     case SESSION_STATE_OPENING:
-          stat->nr_sess_opening--;
-          break;
-     case SESSION_STATE_ACTIVE:
-          stat->nr_sess_active--;
-          break;
-     case SESSION_STATE_CLOSING:
-          stat->nr_sess_closing--;
-          break;
-     case SESSION_STATE_DISCARD:
-          stat->nr_sess_discard--;
-          break;
-     case SESSION_STATE_CLOSED:
-          stat->nr_sess_closed--;
-          break;
-     default:
-          break;
-     }
-}
-
-static void session_stat_update(struct session_manager *mgr, struct session *sess, enum session_state curr_state, enum session_state next_state)
-{
-     switch (session_get_type(sess))
-     {
-     case SESSION_TYPE_TCP:
-          session_stat_dec(&mgr->stat.tcp_sess, curr_state);
-          session_stat_inc(&mgr->stat.tcp_sess, next_state);
-          break;
-     case SESSION_TYPE_UDP:
-          session_stat_dec(&mgr->stat.udp_sess, curr_state);
-          session_stat_inc(&mgr->stat.udp_sess, next_state);
-          break;
-     default:
-          break;
-     }
-}
-
 /******************************************************************************
  * Session Direction
  ******************************************************************************/
@@ -405,20 +420,16 @@ static int session_manager_self_protection(struct session_manager *mgr, struct s
      switch (key->ip_proto)
      {
      case IPPROTO_TCP:
-          if (stat->tcp_sess.nr_sess_used >= mgr->opts.max_tcp_session_num)
+          if (stat->nr_tcp_sess_used >= mgr->opts.max_tcp_session_num)
           {
-               stat->evc_pkt.nr_pkts++;
-               stat->evc_pkt.nr_bytes += packet_get_len(pkt);
-               stat->tcp_sess.nr_new_sess_evicted++;
+               stat->nr_tcp_pkts_bypass_no_space++;
                return 1;
           }
           break;
      case IPPROTO_UDP:
-          if (stat->udp_sess.nr_sess_used >= mgr->opts.max_udp_session_num)
+          if (stat->nr_udp_sess_used >= mgr->opts.max_udp_session_num)
           {
-               stat->evc_pkt.nr_pkts++;
-               stat->evc_pkt.nr_bytes += packet_get_len(pkt);
-               stat->udp_sess.nr_new_sess_evicted++;
+               stat->nr_udp_pkts_bypass_no_space++;
                return 1;
           }
           break;
@@ -434,8 +445,7 @@ static int session_manager_filter_evicted_session(struct session_manager *mgr, s
 {
      if (mgr->opts.evicted_session_filter_enable && evicted_session_filter_lookup(mgr->evicte_sess_filter, key, now))
      {
-          mgr->stat.evc_pkt.nr_pkts++;
-          mgr->stat.evc_pkt.nr_bytes += packet_get_len(pkt);
+          mgr->stat.nr_udp_pkts_bypass_hit_evc++;
           return 1;
      }
 
@@ -457,8 +467,7 @@ static int session_manager_filter_duplicated_packet(struct session_manager *mgr,
      {
           if (duplicated_packet_filter_lookup(mgr->dup_pkt_filter, pkt, now))
           {
-               mgr->stat.dup_pkt.nr_pkts++;
-               mgr->stat.dup_pkt.nr_bytes += packet_get_len(pkt);
+               mgr->stat.nr_tcp_pkts_bypass_hit_dup++;
                session_set_dup_traffic(sess);
                return 1;
           }
@@ -570,7 +579,6 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
      enum session_state next_state = session_transition_run(curr_state, LRU_EVICT);
      session_transition_log(sess, curr_state, next_state, LRU_EVICT);
      session_set_state(sess, next_state);
-     session_stat_update(mgr, sess, curr_state, next_state);
 
      session_timer_del(mgr->sess_timer, sess);
      session_set_closing_reason(sess, CLOSING_BY_EVICTED);
@@ -580,17 +588,19 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
      {
      case SESSION_TYPE_TCP:
           SESSION_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess));
-          mgr->stat.tcp_sess.nr_old_sess_evicted++;
           session_table_del(mgr->tcp_sess_table, session_get_tuple(sess));
+          NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
+          mgr->stat.nr_tcp_sess_evicted++;
           break;
      case SESSION_TYPE_UDP:
           SESSION_LOG_DEBUG("evicte udp old session: %lu", session_get_id(sess));
-          mgr->stat.udp_sess.nr_old_sess_evicted++;
           session_table_del(mgr->udp_sess_table, session_get_tuple(sess));
           if (mgr->opts.evicted_session_filter_enable)
           {
                evicted_session_filter_add(mgr->evicte_sess_filter, session_get_tuple(sess), now);
           }
+          NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
+          mgr->stat.nr_udp_sess_evicted++;
           break;
      default:
           assert(0);
@@ -605,11 +615,12 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
      uint8_t flags = tcp_hdr_get_flags(hdr);
      if (!(flags & TH_SYN))
      {
+          mgr->stat.nr_tcp_pkts_bypass_miss_sess++;
           return NULL;
      }
 
      // tcp table full evict old session
-     if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.tcp_sess.nr_sess_used >= mgr->opts.max_tcp_session_num - EVICTE_SESSION_BURST)
+     if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.nr_tcp_sess_used >= mgr->opts.max_tcp_session_num - EVICTE_SESSION_BURST)
      {
           struct session *evic_sess = session_table_find_lru(mgr->tcp_sess_table);
           session_manager_evicte_session(mgr, evic_sess, now);
@@ -623,6 +634,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
           return NULL;
      }
      session_init(sess);
+     sess->mgr_stat = &mgr->stat;
      session_set_id(sess, id_generator_alloc());
 
      if (tcp_pcb_init(&sess->tcp_pcb, mgr->opts.tcp_reassembly_enable, mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments) == -1)
@@ -631,12 +643,11 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
           session_pool_push(mgr->sess_pool, sess);
           return NULL;
      }
-     tcp_pcb_update(&sess->tcp_pcb, dir, tcp_layer, now);
+     tcp_pcb_update(&mgr->stat, &sess->tcp_pcb, dir, tcp_layer, now);
 
      enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
      session_update(sess, next_state, pkt, key, dir, now);
      session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
-     session_stat_inc(&mgr->stat.tcp_sess, next_state);
 
      uint64_t timeout = (flags & TH_ACK) ? mgr->opts.tcp_handshake_timeout : mgr->opts.tcp_init_timeout;
      session_timer_update(mgr->sess_timer, sess, now + timeout);
@@ -648,7 +659,8 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
           duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, now);
      }
 
-     mgr->stat.tcp_sess.nr_sess_used++;
+     NR_TCP_SESS_STAT_INC(&mgr->stat, next_state);
+     mgr->stat.nr_tcp_sess_used++;
 
      return sess;
 }
@@ -656,7 +668,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
 static struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
 {
      // udp table full evict old session
-     if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.udp_sess.nr_sess_used >= mgr->opts.max_udp_session_num - EVICTE_SESSION_BURST)
+     if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.nr_udp_sess_used >= mgr->opts.max_udp_session_num - EVICTE_SESSION_BURST)
      {
           struct session *evic_sess = session_table_find_lru(mgr->udp_sess_table);
           session_manager_evicte_session(mgr, evic_sess, now);
@@ -668,19 +680,21 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
           assert(sess);
           return NULL;
      }
-     mgr->stat.udp_sess.nr_sess_used++;
      session_init(sess);
+     sess->mgr_stat = &mgr->stat;
      session_set_id(sess, id_generator_alloc());
 
      enum session_dir dir = identify_direction_by_port(ntohs(key->src_port), ntohs(key->dst_port));
      enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA);
      session_update(sess, next_state, pkt, key, dir, now);
      session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
-     session_stat_inc(&mgr->stat.udp_sess, next_state);
 
      session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
      session_table_add(mgr->udp_sess_table, key, sess);
 
+     NR_UDP_SESS_STAT_INC(&mgr->stat, next_state);
+     mgr->stat.nr_udp_sess_used++;
+
      return sess;
 }
 
@@ -702,11 +716,10 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
 
      // update session
      session_update(sess, next_state, pkt, key, dir, now);
-     session_stat_update(mgr, sess, curr_state, next_state);
      session_transition_log(sess, curr_state, next_state, inputs);
 
      // update tcp pcb
-     tcp_pcb_update(&sess->tcp_pcb, dir, tcp_layer, now);
+     tcp_pcb_update(&mgr->stat, &sess->tcp_pcb, dir, tcp_layer, now);
 
      if (mgr->opts.duplicated_packet_filter_enable)
      {
@@ -770,6 +783,8 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
      }
      session_timer_update(mgr->sess_timer, sess, now + timeout);
 
+     NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
+
      return 0;
 }
 
@@ -780,9 +795,10 @@ static int session_manager_update_udp_session(struct session_manager *mgr, struc
      enum session_state next_state = session_transition_run(curr_state, UDP_DATA);
      session_update(sess, next_state, pkt, key, dir, now);
      session_transition_log(sess, curr_state, next_state, UDP_DATA);
-     session_stat_update(mgr, sess, curr_state, next_state);
      session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
 
+     NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
+
      return 0;
 }
 
@@ -913,13 +929,13 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
           case SESSION_TYPE_TCP:
                tcp_pcb_clean(&sess->tcp_pcb);
                session_table_del(mgr->tcp_sess_table, session_get_tuple(sess));
-               session_stat_dec(&mgr->stat.tcp_sess, session_get_state(sess));
-               mgr->stat.tcp_sess.nr_sess_used--;
+               NR_TCP_SESS_STAT_DEC(&mgr->stat, session_get_state(sess));
+               mgr->stat.nr_tcp_sess_used--;
                break;
           case SESSION_TYPE_UDP:
                session_table_del(mgr->udp_sess_table, session_get_tuple(sess));
-               session_stat_dec(&mgr->stat.udp_sess, session_get_state(sess));
-               mgr->stat.udp_sess.nr_sess_used--;
+               NR_UDP_SESS_STAT_DEC(&mgr->stat, session_get_state(sess));
+               mgr->stat.nr_udp_sess_used--;
                break;
           default:
                assert(0);
@@ -984,7 +1000,22 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
           enum session_state next_state = session_transition_run(curr_state, TIMEOUT);
           session_transition_log(sess, curr_state, next_state, TIMEOUT);
           session_set_state(sess, next_state);
-          session_stat_update(mgr, sess, curr_state, next_state);
+
+          uint64_t timeout = 0;
+          switch (session_get_type(sess))
+          {
+          case SESSION_TYPE_TCP:
+               timeout = mgr->opts.tcp_data_timeout;
+               NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
+               break;
+          case SESSION_TYPE_UDP:
+               timeout = mgr->opts.udp_data_timeout;
+               NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
+               break;
+          default:
+               assert(0);
+               break;
+          }
 
           if (next_state == SESSION_STATE_CLOSED)
           {
@@ -998,19 +1029,6 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
           else
           {
                // in closing state, only update timeout
-               uint64_t timeout = 0;
-               switch (session_get_type(sess))
-               {
-               case SESSION_TYPE_TCP:
-                    timeout = mgr->opts.tcp_data_timeout;
-                    break;
-               case SESSION_TYPE_UDP:
-                    timeout = mgr->opts.udp_data_timeout;
-                    break;
-               default:
-                    assert(0);
-                    break;
-               }
                session_timer_update(mgr->sess_timer, sess, now + timeout);
                return NULL;
           }
@@ -1042,17 +1060,14 @@ void session_manager_print_stat(struct session_manager *mgr)
 {
      if (mgr)
      {
-          SESSION_LOG_DEBUG("session_manager_stat->tcp_sess_num: used: %u, init: %u, opening: %u, active: %u, closing: %u, closed: %u, evic_new: %u, evic_old: %u",
-                            mgr->stat.tcp_sess.nr_sess_used, mgr->stat.tcp_sess.nr_sess_init, mgr->stat.tcp_sess.nr_sess_opening,
-                            mgr->stat.tcp_sess.nr_sess_active, mgr->stat.tcp_sess.nr_sess_closing, mgr->stat.tcp_sess.nr_sess_closed,
-                            mgr->stat.tcp_sess.nr_new_sess_evicted, mgr->stat.tcp_sess.nr_old_sess_evicted);
-          SESSION_LOG_DEBUG("session_manager_stat->udp_sess_num: used: %u, init: %u, opening: %u, active: %u, closing: %u, closed: %u, evic_new: %u, evic_old: %u",
-                            mgr->stat.udp_sess.nr_sess_used, mgr->stat.udp_sess.nr_sess_init, mgr->stat.udp_sess.nr_sess_opening,
-                            mgr->stat.udp_sess.nr_sess_active, mgr->stat.udp_sess.nr_sess_closing, mgr->stat.udp_sess.nr_sess_closed,
-                            mgr->stat.udp_sess.nr_new_sess_evicted, mgr->stat.udp_sess.nr_old_sess_evicted);
-          SESSION_LOG_DEBUG("session_manager_stat: dup_pkts: %u, dup_bytes: %u, evic_pkts: %u, evic_bytes: %u",
-                            mgr->stat.dup_pkt.nr_pkts, mgr->stat.dup_pkt.nr_bytes,
-                            mgr->stat.evc_pkt.nr_pkts, mgr->stat.evc_pkt.nr_bytes);
+          SESSION_LOG_DEBUG("session_manager_stat->tcp_sess: used: %u, opening: %u, active: %u, closing: %u, closed: %u",
+                            mgr->stat.nr_tcp_sess_used, mgr->stat.nr_tcp_sess_opening, mgr->stat.nr_tcp_sess_active,
+                            mgr->stat.nr_tcp_sess_closing, mgr->stat.nr_tcp_sess_closed);
+          SESSION_LOG_DEBUG("session_manager_stat->udp_sess: used: %u, opening: %u, active: %u, closing: %u, closed: %u",
+                            mgr->stat.nr_udp_sess_used, mgr->stat.nr_udp_sess_opening, mgr->stat.nr_udp_sess_active,
+                            mgr->stat.nr_udp_sess_closing, mgr->stat.nr_udp_sess_closed);
+          SESSION_LOG_DEBUG("session_manager_stat->evicted_sess: tcp: %u, udp: %u",
+                            mgr->stat.nr_tcp_sess_evicted, mgr->stat.nr_udp_sess_evicted);
      }
 }
 
diff --git a/src/session/session_manager.h b/src/session/session_manager.h
index 533a781..2334a70 100644
--- a/src/session/session_manager.h
+++ b/src/session/session_manager.h
@@ -51,33 +51,52 @@ struct session_manager_options
     uint32_t tcp_reassembly_max_segments; // range: [2, 32]
 };
 
-struct session_stat
-{
-    uint64_t nr_sess_used;
-    uint64_t nr_sess_init;
-    uint64_t nr_sess_opening;
-    uint64_t nr_sess_active;
-    uint64_t nr_sess_closing;
-    uint64_t nr_sess_discard;
-    uint64_t nr_sess_closed;
-
-    uint64_t nr_new_sess_evicted;
-    uint64_t nr_old_sess_evicted;
-};
-
-struct packet_stat
-{
-    uint64_t nr_pkts;
-    uint64_t nr_bytes;
-};
-
 struct session_manager_stat
 {
-    struct packet_stat dup_pkt;
-    struct packet_stat evc_pkt;
+    /******************************************************
+     * state count
+     ******************************************************/
 
-    struct session_stat tcp_sess;
-    struct session_stat udp_sess;
+    // TCP session
+    uint64_t nr_tcp_sess_used;
+    uint64_t nr_tcp_sess_opening;
+    uint64_t nr_tcp_sess_active;
+    uint64_t nr_tcp_sess_closing;
+    uint64_t nr_tcp_sess_discard;
+    uint64_t nr_tcp_sess_closed;
+
+    // UDP session
+    uint64_t nr_udp_sess_used;
+    uint64_t nr_udp_sess_opening;
+    uint64_t nr_udp_sess_active;
+    uint64_t nr_udp_sess_closing;
+    uint64_t nr_udp_sess_discard;
+    uint64_t nr_udp_sess_closed;
+
+    /******************************************************
+     * sum count
+     ******************************************************/
+
+    // Evicted session
+    uint64_t nr_tcp_sess_evicted;
+    uint64_t nr_udp_sess_evicted;
+
+    // Packet
+    uint64_t nr_udp_pkts_bypass_no_space;
+    uint64_t nr_tcp_pkts_bypass_no_space;
+    uint64_t nr_tcp_pkts_bypass_miss_sess;
+    uint64_t nr_tcp_pkts_bypass_hit_dup;
+    uint64_t nr_udp_pkts_bypass_hit_evc;
+
+    // TCP segments
+    uint64_t nr_tcp_seg_received;
+    uint64_t nr_tcp_seg_expired;
+    uint64_t nr_tcp_seg_overlap;
+    uint64_t nr_tcp_seg_no_space;
+    uint64_t nr_tcp_seg_inorder;
+    uint64_t nr_tcp_seg_reorded;
+    uint64_t nr_tcp_seg_buffered;
+    uint64_t nr_tcp_seg_released;
 };
 
 struct session_manager;
diff --git a/src/session/test/gtest_filter_tcp_dupkt.cpp b/src/session/test/gtest_filter_tcp_dupkt.cpp
index 12b088f..af738ab 100644
--- a/src/session/test/gtest_filter_tcp_dupkt.cpp
+++ b/src/session/test/gtest_filter_tcp_dupkt.cpp
@@ -77,8 +77,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     // C2S SYN dup Packet
     printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -93,8 +92,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 1);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt1_c2s_syn));
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 1);
 
     // C2S SYN retransmission Packet
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -112,8 +110,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 1);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt1_c2s_syn));
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 1);
 
     session_manager_free(mgr);
 }
@@ -143,8 +140,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     // S2C SYNACK dup Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -159,8 +155,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 1);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt2_s2c_syn_ack));
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 1);
 
     // S2C SYNACK retransmission Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n");
@@ -178,8 +173,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 1);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 1);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == sizeof(tcp_pkt2_s2c_syn_ack));
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 1);
 
     session_manager_free(mgr);
 }
@@ -210,8 +204,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     // C2S SYN retransmission Packet
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -228,8 +221,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     // C2S SYN retransmission Packet
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -246,8 +238,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     // C2S SYN dup Packet
     printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -262,8 +253,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     session_manager_free(mgr);
 }
@@ -296,8 +286,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     // C2S SYN dup Packet
     printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -312,8 +301,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     session_manager_free(mgr);
 }
@@ -346,8 +334,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     // S2C SYNACK dup Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -362,8 +349,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
     EXPECT_TRUE(session_has_dup_traffic(sess) == 0);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->dup_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->dup_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_hit_dup == 0);
 
     session_manager_free(mgr);
 }
diff --git a/src/session/test/gtest_overload_evict_tcp_sess.cpp b/src/session/test/gtest_overload_evict_tcp_sess.cpp
index 3bb755f..e6d44a7 100644
--- a/src/session/test/gtest_overload_evict_tcp_sess.cpp
+++ b/src/session/test/gtest_overload_evict_tcp_sess.cpp
@@ -47,7 +47,7 @@ struct session_manager_options opts = {
     .tcp_reassembly_max_segments = 16,
 };
 
-static void packet_set_tcp_src_addr(struct packet *pkt, uint32_t addr)
+static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
 {
     const struct pkt_layer *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
     EXPECT_TRUE(ipv4_layer);
@@ -73,23 +73,21 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
     // new session
     for (uint32_t i = 0; i < opts.max_tcp_session_num; i++)
     {
-        packet_set_tcp_src_addr(&pkt, i);
+        packet_set_ip_src_addr(&pkt, i);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
     }
     printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_init == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closed == RX_BURST_MAX); // have evicted, have't free
-    EXPECT_TRUE(stat->tcp_sess.nr_new_sess_evicted == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_old_sess_evicted == RX_BURST_MAX);
-    EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free
+    EXPECT_TRUE(stat->nr_tcp_sess_evicted == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_no_space == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_miss_sess == 0);
 
     session_manager_free(mgr);
 }
@@ -116,28 +114,26 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     // new session
     for (uint32_t i = 0; i < opts.max_tcp_session_num; i++)
     {
-        packet_set_tcp_src_addr(&pkt, i);
+        packet_set_ip_src_addr(&pkt, i);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
     }
     printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_init == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closed == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_new_sess_evicted == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_old_sess_evicted == 0);
-    EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closed == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_evicted == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_no_space == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_miss_sess == 0);
 
     // table full, evict new session
     for (uint32_t i = 0; i < RX_BURST_MAX; i++)
     {
-        packet_set_tcp_src_addr(&pkt, opts.max_tcp_session_num + i);
+        packet_set_ip_src_addr(&pkt, opts.max_tcp_session_num + i);
         EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
     }
@@ -145,16 +141,14 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_init == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closed == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_new_sess_evicted == RX_BURST_MAX);
-    EXPECT_TRUE(stat->tcp_sess.nr_old_sess_evicted == 0);
-    EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
-    EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(tcp_pkt1_c2s_syn));
+    EXPECT_TRUE(stat->nr_tcp_sess_used == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closed == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_evicted == 0);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_no_space == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_tcp_pkts_bypass_miss_sess == 0);
 
     session_manager_free(mgr);
 }
diff --git a/src/session/test/gtest_overload_evict_udp_sess.cpp b/src/session/test/gtest_overload_evict_udp_sess.cpp
index c6b5ace..218d8c1 100644
--- a/src/session/test/gtest_overload_evict_udp_sess.cpp
+++ b/src/session/test/gtest_overload_evict_udp_sess.cpp
@@ -47,7 +47,7 @@ struct session_manager_options opts = {
     .tcp_reassembly_max_segments = 16,
 };
 
-static void packet_set_tcp_src_addr(struct packet *pkt, uint32_t addr)
+static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
 {
     const struct pkt_layer *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
     EXPECT_TRUE(ipv4_layer);
@@ -74,23 +74,21 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     // new session
     for (uint32_t i = 0; i < opts.max_udp_session_num; i++)
     {
-        packet_set_tcp_src_addr(&pkt, i);
+        packet_set_ip_src_addr(&pkt, i);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
     }
     printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closed == RX_BURST_MAX); // have evicted, have't free
-    EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == RX_BURST_MAX);
-    EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_used == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closed == RX_BURST_MAX); // have evicted, have't free
+    EXPECT_TRUE(stat->nr_udp_sess_evicted == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_no_space == 0);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == 0);
 
     // evicted session
     while (1)
@@ -108,7 +106,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 
     for (uint32_t i = 0; i < RX_BURST_MAX; i++)
     {
-        packet_set_tcp_src_addr(&pkt, i);
+        packet_set_ip_src_addr(&pkt, i);
         EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL); // hit evicted session, can't renew session
     }
@@ -116,35 +114,31 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == RX_BURST_MAX);
-    EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
-    EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(udp_pkt1_dns_req));
+    EXPECT_TRUE(stat->nr_udp_sess_used == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closed == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_evicted == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_no_space == 0);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == RX_BURST_MAX);
 
     // evicted session timeout
-    packet_set_tcp_src_addr(&pkt, 0);
+    packet_set_ip_src_addr(&pkt, 0);
     EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
     EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + opts.evicted_session_filter_timeout));
     printf("=> Session Manager: after evicted session timeout\n");
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == RX_BURST_MAX + 1);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 1); // have evicted, have't free
-    EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == RX_BURST_MAX + 1);
-    EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
-    EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(udp_pkt1_dns_req));
+    EXPECT_TRUE(stat->nr_udp_sess_used == RX_BURST_MAX + 1);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closed == 1); // have evicted, have't free
+    EXPECT_TRUE(stat->nr_udp_sess_evicted == RX_BURST_MAX + 1);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_no_space == 0);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == RX_BURST_MAX);
 
     session_manager_free(mgr);
 }
@@ -171,23 +165,21 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     // new session
     for (uint32_t i = 0; i < opts.max_udp_session_num; i++)
     {
-        packet_set_tcp_src_addr(&pkt, i);
+        packet_set_ip_src_addr(&pkt, i);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
     }
     printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == 0);
-    EXPECT_TRUE(stat->evc_pkt.nr_pkts == 0);
-    EXPECT_TRUE(stat->evc_pkt.nr_bytes == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_used == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closed == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_evicted == 0);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_no_space == 0);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == 0);
 
     // evicted session
     EXPECT_TRUE(session_manager_get_evicted_session(mgr) == NULL);
@@ -195,7 +187,7 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     // table full, evict new session
     for (uint32_t i = 0; i < RX_BURST_MAX; i++)
     {
-        packet_set_tcp_src_addr(&pkt, opts.max_udp_session_num + i);
+        packet_set_ip_src_addr(&pkt, opts.max_udp_session_num + i);
         EXPECT_TRUE(session_manager_lookup_session(mgr, &pkt) == NULL);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
     }
@@ -203,16 +195,14 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_init == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closed == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_new_sess_evicted == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_sess.nr_old_sess_evicted == 0);
-    EXPECT_TRUE(stat->evc_pkt.nr_pkts == RX_BURST_MAX);
-    EXPECT_TRUE(stat->evc_pkt.nr_bytes == RX_BURST_MAX * sizeof(udp_pkt1_dns_req));
+    EXPECT_TRUE(stat->nr_udp_sess_used == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closed == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_evicted == 0);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_no_space == RX_BURST_MAX);
+    EXPECT_TRUE(stat->nr_udp_pkts_bypass_hit_evc == 0);
 
     session_manager_free(mgr);
 }
diff --git a/src/session/test/gtest_state_tcp_active_to_closing.cpp b/src/session/test/gtest_state_tcp_active_to_closing.cpp
index 5c000f7..f2e5a4c 100644
--- a/src/session/test/gtest_state_tcp_active_to_closing.cpp
+++ b/src/session/test/gtest_state_tcp_active_to_closing.cpp
@@ -138,10 +138,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
@@ -156,10 +156,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -226,10 +226,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
@@ -244,10 +244,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -314,10 +314,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
@@ -332,10 +332,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -362,10 +362,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -381,10 +381,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -444,10 +444,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_half_closed_timeout);
@@ -462,10 +462,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -525,10 +525,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_half_closed_timeout);
@@ -543,10 +543,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
diff --git a/src/session/test/gtest_state_tcp_init_to_opening.cpp b/src/session/test/gtest_state_tcp_init_to_opening.cpp
index 7521a07..e3c6bc6 100644
--- a/src/session/test/gtest_state_tcp_init_to_opening.cpp
+++ b/src/session/test/gtest_state_tcp_init_to_opening.cpp
@@ -97,10 +97,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL);           // opening -> closing
@@ -116,10 +116,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -176,10 +176,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_handshake_timeout) == NULL);
@@ -195,10 +195,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -266,10 +266,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -285,10 +285,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -367,10 +367,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
@@ -386,10 +386,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -464,10 +464,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_init_timeout) == NULL);
@@ -483,10 +483,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -562,10 +562,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -581,10 +581,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -652,10 +652,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -671,10 +671,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -742,10 +742,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -761,10 +761,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
diff --git a/src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp b/src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
index c6845e8..907dfac 100644
--- a/src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
+++ b/src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
@@ -402,10 +402,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 11 + opts.tcp_time_wait_timeout);
@@ -420,10 +420,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
diff --git a/src/session/test/gtest_state_tcp_opening_to_active.cpp b/src/session/test/gtest_state_tcp_opening_to_active.cpp
index 534271e..90dd3fc 100644
--- a/src/session/test/gtest_state_tcp_opening_to_active.cpp
+++ b/src/session/test/gtest_state_tcp_opening_to_active.cpp
@@ -107,10 +107,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -126,10 +126,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -197,10 +197,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -216,10 +216,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
diff --git a/src/session/test/gtest_state_tcp_opening_to_closing.cpp b/src/session/test/gtest_state_tcp_opening_to_closing.cpp
index 271dbc3..b5150aa 100644
--- a/src/session/test/gtest_state_tcp_opening_to_closing.cpp
+++ b/src/session/test/gtest_state_tcp_opening_to_closing.cpp
@@ -119,10 +119,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
@@ -137,10 +137,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -215,10 +215,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
@@ -233,10 +233,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -311,10 +311,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
@@ -329,10 +329,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -368,10 +368,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL);
@@ -387,10 +387,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -458,10 +458,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -477,10 +477,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -559,10 +559,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
@@ -578,10 +578,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -649,10 +649,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
@@ -667,10 +667,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -738,10 +738,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
@@ -756,10 +756,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
diff --git a/src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp b/src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
index 2e97440..3c9b2d6 100644
--- a/src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
+++ b/src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
@@ -122,10 +122,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 1);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 1);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.udp_data_timeout) == NULL);           // active -> closing
@@ -141,10 +141,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
diff --git a/src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp b/src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp
index c538cc1..29b3e51 100644
--- a/src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp
+++ b/src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp
@@ -97,10 +97,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL);           // opening -> closing
@@ -116,10 +116,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -177,10 +177,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == 1);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 1);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_used == 1);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == 1);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL);           // opening -> closing
@@ -198,10 +198,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     session_manager_print_stat(mgr);
     stat = session_manager_get_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_used == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_opening == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess.nr_sess_closing == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_used == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_opening == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_active == 0);
+    EXPECT_TRUE(stat->nr_udp_sess_closing == 0);
 
     session_manager_free(mgr);
 }