session manager stat metric rename

14 files changed, 372 insertions, 372 deletions

diff --git a/src/core/stellar_core.cpp b/src/core/stellar_core.cpp
index 7d033d9..27592df 100644
--- a/src/core/stellar_core.cpp
+++ b/src/core/stellar_core.cpp
@@ -393,12 +393,12 @@ static int all_session_have_freed(struct stellar_runtime *runtime, struct stella
         struct session_manager *sess_mgr = runtime->threads[i].sess_mgr;
         struct session_manager_stat *sess_stat = session_manager_stat(sess_mgr);
 
-        if (ATOMIC_READ(&sess_stat->curr_tcp_sess_used) != 0)
+        if (ATOMIC_READ(&sess_stat->tcp_sess_used) != 0)
         {
             return 0;
         }
 
-        if (ATOMIC_READ(&sess_stat->curr_udp_sess_used) != 0)
+        if (ATOMIC_READ(&sess_stat->udp_sess_used) != 0)
         {
             return 0;
         }
diff --git a/src/core/stellar_stat.cpp b/src/core/stellar_stat.cpp
index c765bc5..3e7799d 100644
--- a/src/core/stellar_stat.cpp
+++ b/src/core/stellar_stat.cpp
@@ -53,20 +53,20 @@ static inline uint64_t get_ip6_flow_fail_many_frag(struct thread_stat *thr_stat)
 static inline uint64_t get_ip6_flow_fail_invalid_length(struct thread_stat *thr_stat) { return thr_stat->ip_reassembly->ip6_flow_fail_invalid_length; }
 static inline uint64_t get_ip6_flow_bypass_dup_fist_frag(struct thread_stat *thr_stat) { return thr_stat->ip_reassembly->ip6_flow_bypass_dup_fist_frag; }
 static inline uint64_t get_ip6_flow_bypass_dup_last_frag(struct thread_stat *thr_stat) { return thr_stat->ip_reassembly->ip6_flow_bypass_dup_last_frag; }
-static inline uint64_t get_total_tcp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->total_tcp_sess_used; }
-static inline uint64_t get_curr_tcp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_used; }
-static inline uint64_t get_curr_tcp_sess_opening(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_opening; }
-static inline uint64_t get_curr_tcp_sess_active(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_active; }
-static inline uint64_t get_curr_tcp_sess_closing(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_closing; }
-static inline uint64_t get_curr_tcp_sess_discard(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_discard; }
-static inline uint64_t get_curr_tcp_sess_closed(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_tcp_sess_closed; }
-static inline uint64_t get_total_udp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->total_udp_sess_used; }
-static inline uint64_t get_curr_udp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_used; }
-static inline uint64_t get_curr_udp_sess_opening(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_opening; }
-static inline uint64_t get_curr_udp_sess_active(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_active; }
-static inline uint64_t get_curr_udp_sess_closing(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_closing; }
-static inline uint64_t get_curr_udp_sess_discard(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_discard; }
-static inline uint64_t get_curr_udp_sess_closed(struct thread_stat *thr_stat) { return thr_stat->session_mgr->curr_udp_sess_closed; }
+static inline uint64_t get_history_tcp_sessions(struct thread_stat *thr_stat) { return thr_stat->session_mgr->history_tcp_sessions; }
+static inline uint64_t get_tcp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_sess_used; }
+static inline uint64_t get_tcp_sess_opening(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_sess_opening; }
+static inline uint64_t get_tcp_sess_active(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_sess_active; }
+static inline uint64_t get_tcp_sess_closing(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_sess_closing; }
+static inline uint64_t get_tcp_sess_discard(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_sess_discard; }
+static inline uint64_t get_tcp_sess_closed(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_sess_closed; }
+static inline uint64_t get_history_udp_sessions(struct thread_stat *thr_stat) { return thr_stat->session_mgr->history_udp_sessions; }
+static inline uint64_t get_udp_sess_used(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_sess_used; }
+static inline uint64_t get_udp_sess_opening(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_sess_opening; }
+static inline uint64_t get_udp_sess_active(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_sess_active; }
+static inline uint64_t get_udp_sess_closing(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_sess_closing; }
+static inline uint64_t get_udp_sess_discard(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_sess_discard; }
+static inline uint64_t get_udp_sess_closed(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_sess_closed; }
 static inline uint64_t get_tcp_sess_evicted(struct thread_stat *thr_stat) { return thr_stat->session_mgr->tcp_sess_evicted; }
 static inline uint64_t get_udp_sess_evicted(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_sess_evicted; }
 static inline uint64_t get_udp_pkts_bypass_table_full(struct thread_stat *thr_stat) { return thr_stat->session_mgr->udp_pkts_bypass_table_full; }
@@ -144,21 +144,21 @@ struct metric_schema
         {"ip6_flow_bypass_dup_fist_frag", get_ip6_flow_bypass_dup_fist_frag},
         {"ip6_flow_bypass_dup_last_frag", get_ip6_flow_bypass_dup_last_frag},
         // TCP session
-        {"total_tcp_sess_used", get_total_tcp_sess_used},
-        {"curr_tcp_sess_used", get_curr_tcp_sess_used},
-        {"curr_tcp_sess_opening", get_curr_tcp_sess_opening},
-        {"curr_tcp_sess_active", get_curr_tcp_sess_active},
-        {"curr_tcp_sess_closing", get_curr_tcp_sess_closing},
-        {"curr_tcp_sess_discard", get_curr_tcp_sess_discard},
-        {"curr_tcp_sess_closed", get_curr_tcp_sess_closed},
+        {"history_tcp_sessions", get_history_tcp_sessions},
+        {"tcp_sess_used", get_tcp_sess_used},
+        {"tcp_sess_opening", get_tcp_sess_opening},
+        {"tcp_sess_active", get_tcp_sess_active},
+        {"tcp_sess_closing", get_tcp_sess_closing},
+        {"tcp_sess_discard", get_tcp_sess_discard},
+        {"tcp_sess_closed", get_tcp_sess_closed},
         // UDP session
-        {"total_udp_sess_used", get_total_udp_sess_used},
-        {"curr_udp_sess_used", get_curr_udp_sess_used},
-        {"curr_udp_sess_opening", get_curr_udp_sess_opening},
-        {"curr_udp_sess_active", get_curr_udp_sess_active},
-        {"curr_udp_sess_closing", get_curr_udp_sess_closing},
-        {"curr_udp_sess_discard", get_curr_udp_sess_discard},
-        {"curr_udp_sess_closed", get_curr_udp_sess_closed},
+        {"history_udp_sessions", get_history_udp_sessions},
+        {"udp_sess_used", get_udp_sess_used},
+        {"udp_sess_opening", get_udp_sess_opening},
+        {"udp_sess_active", get_udp_sess_active},
+        {"udp_sess_closing", get_udp_sess_closing},
+        {"udp_sess_discard", get_udp_sess_discard},
+        {"udp_sess_closed", get_udp_sess_closed},
         // Evicted session
         {"tcp_sess_evicted", get_tcp_sess_evicted},
         {"udp_sess_evicted", get_udp_sess_evicted},
diff --git a/src/session/session_manager.cpp b/src/session/session_manager.cpp
index bc70d0a..14e990e 100644
--- a/src/session/session_manager.cpp
+++ b/src/session/session_manager.cpp
@@ -46,52 +46,52 @@ struct session_manager
  * Session Manager Stat
  ******************************************************************************/
 
-#define SESS_MGR_STAT_INC(stat, state, proto)         \
-     {                                                \
-          switch ((state))                            \
-          {                                           \
-          case SESSION_STATE_OPENING:                 \
-               (stat)->curr_##proto##_sess_opening++; \
-               break;                                 \
-          case SESSION_STATE_ACTIVE:                  \
-               (stat)->curr_##proto##_sess_active++;  \
-               break;                                 \
-          case SESSION_STATE_CLOSING:                 \
-               (stat)->curr_##proto##_sess_closing++; \
-               break;                                 \
-          case SESSION_STATE_DISCARD:                 \
-               (stat)->curr_##proto##_sess_discard++; \
-               break;                                 \
-          case SESSION_STATE_CLOSED:                  \
-               (stat)->curr_##proto##_sess_closed++;  \
-               break;                                 \
-          default:                                    \
-               break;                                 \
-          }                                           \
-     }
-
-#define SESS_MGR_STAT_DEC(stat, state, proto)         \
-     {                                                \
-          switch ((state))                            \
-          {                                           \
-          case SESSION_STATE_OPENING:                 \
-               (stat)->curr_##proto##_sess_opening--; \
-               break;                                 \
-          case SESSION_STATE_ACTIVE:                  \
-               (stat)->curr_##proto##_sess_active--;  \
-               break;                                 \
-          case SESSION_STATE_CLOSING:                 \
-               (stat)->curr_##proto##_sess_closing--; \
-               break;                                 \
-          case SESSION_STATE_DISCARD:                 \
-               (stat)->curr_##proto##_sess_discard--; \
-               break;                                 \
-          case SESSION_STATE_CLOSED:                  \
-               (stat)->curr_##proto##_sess_closed--;  \
-               break;                                 \
-          default:                                    \
-               break;                                 \
-          }                                           \
+#define SESS_MGR_STAT_INC(stat, state, proto)  \
+     {                                         \
+          switch ((state))                     \
+          {                                    \
+          case SESSION_STATE_OPENING:          \
+               (stat)->proto##_sess_opening++; \
+               break;                          \
+          case SESSION_STATE_ACTIVE:           \
+               (stat)->proto##_sess_active++;  \
+               break;                          \
+          case SESSION_STATE_CLOSING:          \
+               (stat)->proto##_sess_closing++; \
+               break;                          \
+          case SESSION_STATE_DISCARD:          \
+               (stat)->proto##_sess_discard++; \
+               break;                          \
+          case SESSION_STATE_CLOSED:           \
+               (stat)->proto##_sess_closed++;  \
+               break;                          \
+          default:                             \
+               break;                          \
+          }                                    \
+     }
+
+#define SESS_MGR_STAT_DEC(stat, state, proto)  \
+     {                                         \
+          switch ((state))                     \
+          {                                    \
+          case SESSION_STATE_OPENING:          \
+               (stat)->proto##_sess_opening--; \
+               break;                          \
+          case SESSION_STATE_ACTIVE:           \
+               (stat)->proto##_sess_active--;  \
+               break;                          \
+          case SESSION_STATE_CLOSING:          \
+               (stat)->proto##_sess_closing--; \
+               break;                          \
+          case SESSION_STATE_DISCARD:          \
+               (stat)->proto##_sess_discard--; \
+               break;                          \
+          case SESSION_STATE_CLOSED:           \
+               (stat)->proto##_sess_closed--;  \
+               break;                          \
+          default:                             \
+               break;                          \
+          }                                    \
      }
 
 #define SESS_MGR_STAT_UPDATE(stat, curr, next, proto) \
@@ -456,7 +456,7 @@ static enum flow_direction identify_direction_by_history(const struct session *s
 // on new session
 static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key)
 {
-     if (key->ip_proto == IPPROTO_TCP && mgr->stat.curr_tcp_sess_used >= mgr->opts.max_tcp_session_num)
+     if (key->ip_proto == IPPROTO_TCP && mgr->stat.tcp_sess_used >= mgr->opts.max_tcp_session_num)
      {
           mgr->stat.tcp_pkts_bypass_table_full++;
           return 1;
@@ -466,7 +466,7 @@ static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6
 
 static int udp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key)
 {
-     if (key->ip_proto == IPPROTO_UDP && mgr->stat.curr_udp_sess_used >= mgr->opts.max_udp_session_num)
+     if (key->ip_proto == IPPROTO_UDP && mgr->stat.udp_sess_used >= mgr->opts.max_udp_session_num)
      {
           mgr->stat.udp_pkts_bypass_table_full++;
           return 1;
@@ -691,7 +691,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
      }
 
      // tcp table full evict old session
-     if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.curr_tcp_sess_used >= mgr->opts.max_tcp_session_num - EVICTE_SESSION_BURST)
+     if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.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, LRU_EVICT);
@@ -730,8 +730,8 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
      }
 
      SESS_MGR_STAT_INC(&mgr->stat, next_state, tcp);
-     mgr->stat.curr_tcp_sess_used++;
-     mgr->stat.total_tcp_sess_used++;
+     mgr->stat.tcp_sess_used++;
+     mgr->stat.history_tcp_sessions++;
 
      return sess;
 }
@@ -739,7 +739,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)
 {
      // udp table full evict old session
-     if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.curr_udp_sess_used >= mgr->opts.max_udp_session_num - EVICTE_SESSION_BURST)
+     if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.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, LRU_EVICT);
@@ -764,8 +764,8 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
      session_table_add(mgr->udp_sess_table, sess);
 
      SESS_MGR_STAT_INC(&mgr->stat, next_state, udp);
-     mgr->stat.curr_udp_sess_used++;
-     mgr->stat.total_udp_sess_used++;
+     mgr->stat.udp_sess_used++;
+     mgr->stat.history_udp_sessions++;
 
      return sess;
 }
@@ -1030,7 +1030,7 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
                     session_table_del(mgr->tcp_sess_table, sess);
                }
                SESS_MGR_STAT_DEC(&mgr->stat, session_get_current_state(sess), tcp);
-               mgr->stat.curr_tcp_sess_used--;
+               mgr->stat.tcp_sess_used--;
                break;
           case SESSION_TYPE_UDP:
                if (session_table_find_sessid(mgr->udp_sess_table, session_get_id(sess), 0) == sess)
@@ -1038,7 +1038,7 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
                     session_table_del(mgr->udp_sess_table, sess);
                }
                SESS_MGR_STAT_DEC(&mgr->stat, session_get_current_state(sess), udp);
-               mgr->stat.curr_udp_sess_used--;
+               mgr->stat.udp_sess_used--;
                break;
           default:
                assert(0);
diff --git a/src/session/session_manager.h b/src/session/session_manager.h
index 184a902..6d3745a 100644
--- a/src/session/session_manager.h
+++ b/src/session/session_manager.h
@@ -48,22 +48,22 @@ struct session_manager_options
 struct session_manager_stat
 {
     // TCP session
-    uint64_t total_tcp_sess_used;
-    uint64_t curr_tcp_sess_used;
-    uint64_t curr_tcp_sess_opening;
-    uint64_t curr_tcp_sess_active;
-    uint64_t curr_tcp_sess_closing;
-    uint64_t curr_tcp_sess_discard;
-    uint64_t curr_tcp_sess_closed;
+    uint64_t history_tcp_sessions;
+    uint64_t tcp_sess_used;
+    uint64_t tcp_sess_opening;
+    uint64_t tcp_sess_active;
+    uint64_t tcp_sess_closing;
+    uint64_t tcp_sess_discard;
+    uint64_t tcp_sess_closed;
 
     // UDP session
-    uint64_t total_udp_sess_used;
-    uint64_t curr_udp_sess_used;
-    uint64_t curr_udp_sess_opening;
-    uint64_t curr_udp_sess_active;
-    uint64_t curr_udp_sess_closing;
-    uint64_t curr_udp_sess_discard;
-    uint64_t curr_udp_sess_closed;
+    uint64_t history_udp_sessions;
+    uint64_t udp_sess_used;
+    uint64_t udp_sess_opening;
+    uint64_t udp_sess_active;
+    uint64_t udp_sess_closing;
+    uint64_t udp_sess_discard;
+    uint64_t udp_sess_closed;
 
     // Evicted session
     uint64_t tcp_sess_evicted; // sum
diff --git a/src/session/test/gtest_case_tcp_fast_open.cpp b/src/session/test/gtest_case_tcp_fast_open.cpp
index 51eca6c..5483da8 100644
--- a/src/session/test/gtest_case_tcp_fast_open.cpp
+++ b/src/session/test/gtest_case_tcp_fast_open.cpp
@@ -392,10 +392,10 @@ TEST(CASE, TCP_FAST_OPEN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL);           // opening -> closing
@@ -410,10 +410,10 @@ TEST(CASE, TCP_FAST_OPEN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 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 c8a77b8..5a7fe93 100644
--- a/src/session/test/gtest_overload_evict_tcp_sess.cpp
+++ b/src/session/test/gtest_overload_evict_tcp_sess.cpp
@@ -81,11 +81,11 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
     printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free
+    EXPECT_TRUE(stat->tcp_sess_used == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->tcp_sess_opening == RX_BURST_MAX);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free
     EXPECT_TRUE(stat->tcp_sess_evicted == RX_BURST_MAX);
     EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0);
@@ -122,11 +122,11 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     printf("=> Session Manager: after add %lu new sessions\n", opts.max_tcp_session_num);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closed == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->tcp_sess_opening == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_closed == 0);
     EXPECT_TRUE(stat->tcp_sess_evicted == 0);
     EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0);
@@ -141,11 +141,11 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     printf("=> Session Manager: after evicte new session\n");
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == opts.max_tcp_session_num);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closed == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->tcp_sess_opening == opts.max_tcp_session_num);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_closed == 0);
     EXPECT_TRUE(stat->tcp_sess_evicted == 0);
     EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == RX_BURST_MAX);
     EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0);
diff --git a/src/session/test/gtest_overload_evict_udp_sess.cpp b/src/session/test/gtest_overload_evict_udp_sess.cpp
index fc59746..388e424 100644
--- a/src/session/test/gtest_overload_evict_udp_sess.cpp
+++ b/src/session/test/gtest_overload_evict_udp_sess.cpp
@@ -82,11 +82,11 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closed == RX_BURST_MAX); // have evicted, have't free
+    EXPECT_TRUE(stat->udp_sess_used == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_closed == RX_BURST_MAX); // have evicted, have't free
     EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX);
     EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0);
@@ -114,11 +114,11 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == RX_BURST_MAX);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closed == 0);
+    EXPECT_TRUE(stat->udp_sess_used == RX_BURST_MAX);
+    EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_closed == 0);
     EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX);
     EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
@@ -130,11 +130,11 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     printf("=> Session Manager: after evicted session timeout\n");
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == RX_BURST_MAX + 1);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closed == 1); // have evicted, have't free
+    EXPECT_TRUE(stat->udp_sess_used == RX_BURST_MAX + 1);
+    EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_closed == 1); // have evicted, have't free
     EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX + 1);
     EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
@@ -171,11 +171,11 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     printf("=> Session Manager: after add %lu new sessions\n", opts.max_udp_session_num);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closed == 0);
+    EXPECT_TRUE(stat->udp_sess_used == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->udp_sess_opening == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_closed == 0);
     EXPECT_TRUE(stat->udp_sess_evicted == 0);
     EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0);
@@ -193,11 +193,11 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == opts.max_udp_session_num);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closed == 0);
+    EXPECT_TRUE(stat->udp_sess_used == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->udp_sess_opening == opts.max_udp_session_num);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_closed == 0);
     EXPECT_TRUE(stat->udp_sess_evicted == 0);
     EXPECT_TRUE(stat->udp_pkts_bypass_table_full == RX_BURST_MAX);
     EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0);
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 7e7b8a6..55563d1 100644
--- a/src/session/test/gtest_state_tcp_active_to_closing.cpp
+++ b/src/session/test/gtest_state_tcp_active_to_closing.cpp
@@ -145,10 +145,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
@@ -162,10 +162,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -232,10 +232,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
@@ -249,10 +249,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -319,10 +319,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_unverified_rst_timeout);
@@ -336,10 +336,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -365,10 +365,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 1);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -383,10 +383,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -446,10 +446,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_half_closed_timeout);
@@ -463,10 +463,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -526,10 +526,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->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)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->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 4b80710..a8ba928 100644
--- a/src/session/test/gtest_state_tcp_init_to_opening.cpp
+++ b/src/session/test/gtest_state_tcp_init_to_opening.cpp
@@ -101,10 +101,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL);           // opening -> closing
@@ -119,10 +119,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -179,10 +179,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_handshake_timeout) == NULL);
@@ -197,10 +197,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -269,10 +269,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -287,10 +287,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -371,10 +371,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
@@ -389,10 +389,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -468,10 +468,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_init_timeout) == NULL);
@@ -486,10 +486,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -566,10 +566,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -584,10 +584,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -656,10 +656,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -674,10 +674,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -746,10 +746,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -764,10 +764,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->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 9b46856..05b0240 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
@@ -416,10 +416,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 11 + opts.tcp_time_wait_timeout);
@@ -433,10 +433,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->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 0f3c8a3..d8a6cbb 100644
--- a/src/session/test/gtest_state_tcp_opening_to_active.cpp
+++ b/src/session/test/gtest_state_tcp_opening_to_active.cpp
@@ -112,10 +112,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 1);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -130,10 +130,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -202,10 +202,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 1);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_data_timeout) == NULL);
@@ -220,10 +220,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->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 43ee635..6926aa5 100644
--- a/src/session/test/gtest_state_tcp_opening_to_closing.cpp
+++ b/src/session/test/gtest_state_tcp_opening_to_closing.cpp
@@ -125,10 +125,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 3 + opts.tcp_time_wait_timeout);
@@ -142,10 +142,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -221,10 +221,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
@@ -238,10 +238,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -317,10 +317,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_unverified_rst_timeout);
@@ -334,10 +334,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -373,10 +373,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.tcp_init_timeout) == NULL);
@@ -391,10 +391,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -463,10 +463,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.tcp_handshake_timeout) == NULL);
@@ -481,10 +481,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -565,10 +565,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + opts.tcp_data_timeout) == NULL);
@@ -583,10 +583,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -655,10 +655,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
@@ -672,10 +672,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -744,10 +744,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 1);
+    EXPECT_TRUE(stat->tcp_sess_used == 1);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
     sess = session_manager_get_expired_session(mgr, 2 + opts.tcp_half_closed_timeout);
@@ -761,10 +761,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_tcp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_tcp_sess_closing == 0);
+    EXPECT_TRUE(stat->tcp_sess_used == 0);
+    EXPECT_TRUE(stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(stat->tcp_sess_active == 0);
+    EXPECT_TRUE(stat->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 43e287a..f4168cc 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
@@ -127,10 +127,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 1);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_used == 1);
+    EXPECT_TRUE(stat->udp_sess_opening == 0);
+    EXPECT_TRUE(stat->udp_sess_active == 1);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + opts.udp_data_timeout) == NULL);           // active -> closing
@@ -145,10 +145,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_used == 0);
+    EXPECT_TRUE(stat->udp_sess_opening == 0);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->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 a667e0e..df03bf0 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
@@ -101,10 +101,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_used == 1);
+    EXPECT_TRUE(stat->udp_sess_opening == 1);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL);           // opening -> closing
@@ -119,10 +119,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_used == 0);
+    EXPECT_TRUE(stat->udp_sess_opening == 0);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
 
     session_manager_free(mgr);
 }
@@ -180,10 +180,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == 1);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == 1);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_used == 1);
+    EXPECT_TRUE(stat->udp_sess_opening == 1);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
 
     // expire session
     EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + opts.udp_data_timeout) == NULL);           // opening -> closing
@@ -200,10 +200,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     // check stat
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->curr_udp_sess_used == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_opening == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_active == 0);
-    EXPECT_TRUE(stat->curr_udp_sess_closing == 0);
+    EXPECT_TRUE(stat->udp_sess_used == 0);
+    EXPECT_TRUE(stat->udp_sess_opening == 0);
+    EXPECT_TRUE(stat->udp_sess_active == 0);
+    EXPECT_TRUE(stat->udp_sess_closing == 0);
 
     session_manager_free(mgr);
 }