Merge pull request #1866 from fengzeroz/v2.7

version: 2.7.4

.github/workflows/ci.yml

@@ -8,7 +8,7 @@ on:
       - published
 
 env:
-  VERSION: 2.7.2
+  VERSION: 2.7.4
   UI_VERSION: 2.6.3
   BRANCH: v2.7
 

cmake/cross.cmake

@@ -21,3 +21,7 @@ link_directories(${CMAKE_STAGING_PREFIX})
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "mips32")
 	link_libraries(atomic)
 endif()
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "riscv64")
+	link_libraries(atomic)
+endif()

include/neuron/define.h

@@ -24,14 +24,14 @@
 
 #define NEU_VERSION_MAJOR 2
 #define NEU_VERSION_MINOR 7
-#define NEU_VERSION_FIX 2
+#define NEU_VERSION_FIX 4
 
 #define NEU_GET_VERSION_MAJOR(V) ((0xffff0000 & V) >> 16)
 #define NEU_GET_VERSION_MINOR(V) ((0x0000ff00 & V) >> 8)
 #define NEU_GET_VERSION_FIX(V) ((0x000000ff & V))
 #define NEU_VERSION(MAJOR, MINOR, FIX) ((MAJOR << 16) | (MINOR << 8) | FIX)
 
-#define NEU_TAG_NAME_LEN 64
+#define NEU_TAG_NAME_LEN 128
 #define NEU_TAG_ADDRESS_LEN 128
 #define NEU_TAG_DESCRIPTION_LEN 128
 #define NEU_GROUP_MAX_PER_NODE 512

include/neuron/metrics.h

@@ -26,14 +26,21 @@ extern "C" {
 
 #include <stdint.h>
 
+#include <pthread.h>
+
 #include "define.h"
 #include "type.h"
+#include "utils/rolling_counter.h"
+#include "utils/utextend.h"
 #include "utils/uthash.h"
 
+extern int64_t global_timestamp;
+
 typedef enum {
     NEU_METRIC_TYPE_COUNTER,
     NEU_METRIC_TYPE_GAUAGE,
     NEU_METRIC_TYPE_COUNTER_SET,
+    NEU_METRIC_TYPE_ROLLING_COUNTER,
 } neu_metric_type_e;
 
 // node running state
@@ -131,6 +138,96 @@ typedef enum {
 #define NEU_METRIC_RECV_MSGS_TOTAL_TYPE NEU_METRIC_TYPE_COUNTER
 #define NEU_METRIC_RECV_MSGS_TOTAL_HELP "Total number of messages received"
 
+// number of trans data message within the last 5 seconds
+#define NEU_METRIC_TRANS_DATA_5S "last_5s_trans_data_msgs"
+#define NEU_METRIC_TRANS_DATA_5S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_TRANS_DATA_5S_HELP \
+    "Number of internal trans data message within the last 5 seconds"
+
+// number of trans data message within the last 30 seconds
+#define NEU_METRIC_TRANS_DATA_30S "last_30s_trans_data_msgs"
+#define NEU_METRIC_TRANS_DATA_30S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_TRANS_DATA_30S_HELP \
+    "Number of internal trans data message within the last 30 seconds"
+
+// number of trans data message within the last 60 seconds
+#define NEU_METRIC_TRANS_DATA_60S "last_60s_trans_data_msgs"
+#define NEU_METRIC_TRANS_DATA_60S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_TRANS_DATA_60S_HELP \
+    "Number of internal trans data message within the last 60 seconds"
+
+// number of bytes sent within the last 5 seconds
+#define NEU_METRIC_SEND_BYTES_5S "last_5s_send_bytes"
+#define NEU_METRIC_SEND_BYTES_5S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_SEND_BYTES_5S_HELP \
+    "Number of bytes sent within the last 5 seconds"
+
+// number of bytes sent within the last 30 seconds
+#define NEU_METRIC_SEND_BYTES_30S "last_30s_send_bytes"
+#define NEU_METRIC_SEND_BYTES_30S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_SEND_BYTES_30S_HELP \
+    "Number of bytes sent within the last 30 seconds"
+
+// number of bytes sent within the last 60 seconds
+#define NEU_METRIC_SEND_BYTES_60S "last_60s_send_bytes"
+#define NEU_METRIC_SEND_BYTES_60S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_SEND_BYTES_60S_HELP \
+    "Number of bytes sent within the last 60 seconds"
+
+// number of bytes received within the last 5 seconds
+#define NEU_METRIC_RECV_BYTES_5S "last_5s_recv_bytes"
+#define NEU_METRIC_RECV_BYTES_5S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_RECV_BYTES_5S_HELP \
+    "Number of bytes received within the last 5 seconds"
+
+// number of bytes received within the last 30 seconds
+#define NEU_METRIC_RECV_BYTES_30S "last_30s_recv_bytes"
+#define NEU_METRIC_RECV_BYTES_30S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_RECV_BYTES_30S_HELP \
+    "Number of bytes received within the last 30 seconds"
+
+// number of bytes received within the last 60 seconds
+#define NEU_METRIC_RECV_BYTES_60S "last_60s_recv_bytes"
+#define NEU_METRIC_RECV_BYTES_60S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_RECV_BYTES_60S_HELP \
+    "Number of bytes received within the last 60 seconds"
+
+// number of messages received within the last 5 seconds
+#define NEU_METRIC_RECV_MSGS_5S "last_5s_recv_msgs"
+#define NEU_METRIC_RECV_MSGS_5S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_RECV_MSGS_5S_HELP \
+    "Number of messages received within the last 5 seconds"
+
+// number of messages received within the last 30 seconds
+#define NEU_METRIC_RECV_MSGS_30S "last_30s_recv_msgs"
+#define NEU_METRIC_RECV_MSGS_30S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_RECV_MSGS_30S_HELP \
+    "Number of messages received within the last 30 seconds"
+
+// number of messages received within the last 60 seconds
+#define NEU_METRIC_RECV_MSGS_60S "last_60s_recv_msgs"
+#define NEU_METRIC_RECV_MSGS_60S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_RECV_MSGS_60S_HELP \
+    "Number of messages received within the last 60 seconds"
+
+// number of disconnection within the last 60 seconds
+#define NEU_METRIC_DISCONNECTION_60S "last_60s_disconnections"
+#define NEU_METRIC_DISCONNECTION_60S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_DISCONNECTION_60S_HELP \
+    "Number of disconnection within the last 60 seconds"
+
+// number of disconnection within the last 600 seconds
+#define NEU_METRIC_DISCONNECTION_600S "last_600s_disconnections"
+#define NEU_METRIC_DISCONNECTION_600S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_DISCONNECTION_600S_HELP \
+    "Number of disconnection within the last 600 seconds"
+
+// number of disconnection within the last 1800 seconds
+#define NEU_METRIC_DISCONNECTION_1800S "last_1800s_disconnections"
+#define NEU_METRIC_DISCONNECTION_1800S_TYPE NEU_METRIC_TYPE_ROLLING_COUNTER
+#define NEU_METRIC_DISCONNECTION_1800S_HELP \
+    "Number of disconnection within the last 1800 seconds"
+
 typedef enum {
     NEU_METRICS_CATEGORY_GLOBAL,
     NEU_METRICS_CATEGORY_DRIVER,
@@ -140,11 +237,12 @@ typedef enum {
 
 // metric entry
 typedef struct {
-    const char *      name;  // NOTE: should points to string literal
-    const char *      help;  // NOTE: should points to string literal
-    neu_metric_type_e type;  //
-    uint64_t          value; //
-    UT_hash_handle    hh;    // ordered by name
+    const char *           name;  // NOTE: should points to string literal
+    const char *           help;  // NOTE: should points to string literal
+    neu_metric_type_e      type;  //
+    uint64_t               value; //
+    neu_rolling_counter_t *rcnt;  //
+    UT_hash_handle         hh;    // ordered by name
 } neu_metric_entry_t;
 
 // group metrics
@@ -156,6 +254,7 @@ typedef struct {
 
 // node metrics
 typedef struct {
+    pthread_mutex_t      lock;          // spin lock
     neu_node_type_e      type;          // node type
     char *               name;          // node name
     neu_metric_entry_t * entries;       // node metric entries
@@ -192,6 +291,16 @@ typedef struct {
     neu_metric_entry_t *registered_metrics;
 } neu_metrics_t;
 
+void neu_metrics_init();
+void neu_metrics_add_node(const neu_adapter_t *adapter);
+void neu_metrics_del_node(const neu_adapter_t *adapter);
+int  neu_metrics_register_entry(const char *name, const char *help,
+                                neu_metric_type_e type);
+void neu_metrics_unregister_entry(const char *name);
+
+typedef void (*neu_metrics_cb_t)(const neu_metrics_t *metrics, void *data);
+void neu_metrics_visist(neu_metrics_cb_t cb, void *data);
+
 static inline const char *neu_metric_type_str(neu_metric_type_e type)
 {
     if (NEU_METRIC_TYPE_COUNTER == type) {
@@ -207,6 +316,9 @@ int neu_metric_entries_add(neu_metric_entry_t **entries, const char *name,
 
 static inline void neu_metric_entry_free(neu_metric_entry_t *entry)
 {
+    if (NEU_METRIC_TYPE_ROLLING_COUNTER == entry->type) {
+        neu_rolling_counter_free(entry->rcnt);
+    }
     free(entry);
 }
 
@@ -220,22 +332,41 @@ static inline void neu_group_metrics_free(neu_group_metrics_t *group_metrics)
     HASH_ITER(hh, group_metrics->entries, e, tmp)
     {
         HASH_DEL(group_metrics->entries, e);
+        neu_metrics_unregister_entry(e->name);
         neu_metric_entry_free(e);
     }
     free(group_metrics->name);
     free(group_metrics);
 }
 
+static inline neu_node_metrics_t *
+neu_node_metrics_new(neu_adapter_t *adapter, neu_node_type_e type, char *name)
+{
+    neu_node_metrics_t *node_metrics =
+        (neu_node_metrics_t *) calloc(1, sizeof(*node_metrics));
+    if (NULL != node_metrics) {
+        pthread_mutex_init(&node_metrics->lock, NULL);
+        node_metrics->type    = type;
+        node_metrics->name    = name;
+        node_metrics->adapter = adapter;
+        // neu_metrics_add_node(adapter);
+    }
+    return node_metrics;
+}
+
 static inline void neu_node_metrics_free(neu_node_metrics_t *node_metrics)
 {
     if (NULL == node_metrics) {
         return;
     }
 
+    pthread_mutex_destroy(&node_metrics->lock);
+
     neu_metric_entry_t *e = NULL, *etmp = NULL;
     HASH_ITER(hh, node_metrics->entries, e, etmp)
     {
         HASH_DEL(node_metrics->entries, e);
+        neu_metrics_unregister_entry(e->name);
         neu_metric_entry_free(e);
     }
 
@@ -249,15 +380,148 @@ static inline void neu_node_metrics_free(neu_node_metrics_t *node_metrics)
     free(node_metrics);
 }
 
-void neu_metrics_init();
-void neu_metrics_add_node(const neu_adapter_t *adapter);
-void neu_metrics_del_node(const neu_adapter_t *adapter);
-int  neu_metrics_register_entry(const char *name, const char *help,
-                                neu_metric_type_e type);
-void neu_metrics_unregister_entry(const char *name);
+static inline int neu_node_metrics_add(neu_node_metrics_t *node_metrics,
+                                       const char *group_name, const char *name,
+                                       const char *help, neu_metric_type_e type,
+                                       uint64_t init)
+{
+    int rv = 0;
 
-typedef void (*neu_metrics_cb_t)(const neu_metrics_t *metrics, void *data);
-void neu_metrics_visist(neu_metrics_cb_t cb, void *data);
+    if (0 > neu_metrics_register_entry(name, help, type)) {
+        return -1;
+    }
+
+    pthread_mutex_lock(&node_metrics->lock);
+    if (NULL == group_name) {
+        rv = neu_metric_entries_add(&node_metrics->entries, name, help, type,
+                                    init);
+    } else {
+        neu_group_metrics_t *group_metrics = NULL;
+        HASH_FIND_STR(node_metrics->group_metrics, group_name, group_metrics);
+        if (NULL != group_metrics) {
+            rv = neu_metric_entries_add(&group_metrics->entries, name, help,
+                                        type, init);
+        } else {
+            group_metrics =
+                (neu_group_metrics_t *) calloc(1, sizeof(*group_metrics));
+            if (NULL != group_metrics &&
+                NULL != (group_metrics->name = strdup(group_name))) {
+                HASH_ADD_STR(node_metrics->group_metrics, name, group_metrics);
+                rv = neu_metric_entries_add(&group_metrics->entries, name, help,
+                                            type, init);
+            } else {
+                free(group_metrics);
+                rv = -1;
+            }
+        }
+    }
+    pthread_mutex_unlock(&node_metrics->lock);
+
+    if (0 != rv) {
+        neu_metrics_unregister_entry(name);
+    }
+    return rv;
+}
+
+static inline int neu_node_metrics_update(neu_node_metrics_t *node_metrics,
+                                          const char *        group,
+                                          const char *metric_name, uint64_t n)
+{
+    neu_metric_entry_t *entry = NULL;
+
+    pthread_mutex_lock(&node_metrics->lock);
+    if (NULL == group) {
+        HASH_FIND_STR(node_metrics->entries, metric_name, entry);
+    } else if (NULL != node_metrics->group_metrics) {
+        neu_group_metrics_t *g = NULL;
+        HASH_FIND_STR(node_metrics->group_metrics, group, g);
+        if (NULL != g) {
+            HASH_FIND_STR(g->entries, metric_name, entry);
+        }
+    }
+
+    if (NULL == entry) {
+        pthread_mutex_unlock(&node_metrics->lock);
+        return -1;
+    }
+
+    if (NEU_METRIC_TYPE_COUNTER == entry->type) {
+        entry->value += n;
+    } else if (NEU_METRIC_TYPE_ROLLING_COUNTER == entry->type) {
+        entry->value =
+            neu_rolling_counter_inc(entry->rcnt, global_timestamp, n);
+    } else {
+        entry->value = n;
+    }
+    pthread_mutex_unlock(&node_metrics->lock);
+
+    return 0;
+}
+
+static inline void neu_node_metrics_reset(neu_node_metrics_t *node_metrics)
+{
+    neu_metric_entry_t *entry = NULL;
+
+    pthread_mutex_lock(&node_metrics->lock);
+    HASH_LOOP(hh, node_metrics->entries, entry)
+    {
+        entry->value = 0;
+        if (NEU_METRIC_TYPE_ROLLING_COUNTER == entry->type) {
+            neu_rolling_counter_reset(entry->rcnt);
+        }
+    }
+
+    neu_group_metrics_t *g = NULL;
+    HASH_LOOP(hh, node_metrics->group_metrics, g)
+    {
+        HASH_LOOP(hh, g->entries, entry)
+        {
+            entry->value = 0;
+            if (NEU_METRIC_TYPE_ROLLING_COUNTER == entry->type) {
+                neu_rolling_counter_reset(entry->rcnt);
+            }
+        }
+    }
+    pthread_mutex_unlock(&node_metrics->lock);
+}
+
+static inline int
+neu_node_metrics_update_group(neu_node_metrics_t *node_metrics,
+                              const char *        group_name,
+                              const char *        new_group_name)
+{
+    int                  rv            = -1;
+    neu_group_metrics_t *group_metrics = NULL;
+
+    pthread_mutex_lock(&node_metrics->lock);
+    HASH_FIND_STR(node_metrics->group_metrics, group_name, group_metrics);
+    if (NULL != group_metrics) {
+        char *name = strdup(new_group_name);
+        if (NULL != name) {
+            HASH_DEL(node_metrics->group_metrics, group_metrics);
+            free(group_metrics->name);
+            group_metrics->name = name;
+            HASH_ADD_STR(node_metrics->group_metrics, name, group_metrics);
+            rv = 0;
+        }
+    }
+    pthread_mutex_unlock(&node_metrics->lock);
+
+    return rv;
+}
+
+static inline void neu_node_metrics_del_group(neu_node_metrics_t *node_metrics,
+                                              const char *        group_name)
+{
+    neu_group_metrics_t *gm = NULL;
+    pthread_mutex_lock(&node_metrics->lock);
+    HASH_FIND_STR(node_metrics->group_metrics, group_name, gm);
+    if (NULL != gm) {
+        HASH_DEL(node_metrics->group_metrics, gm);
+        neu_group_metrics_free(gm);
+    }
+    pthread_mutex_unlock(&node_metrics->lock);
+}
 
 #ifdef __cplusplus
 }

include/neuron/plugin.h

@@ -36,6 +36,14 @@ extern "C" {
 #define NEURON_PLUGIN_VER_1_0 \
     NEU_VERSION(NEU_VERSION_MAJOR, NEU_VERSION_MINOR, NEU_VERSION_FIX)
 
+#define NEU_PLUGIN_REGISTER_METRIC(plugin, name, init) \
+    plugin->common.adapter_callbacks->register_metric( \
+        plugin->common.adapter, name, name##_HELP, name##_TYPE, init)
+
+#define NEU_PLUGIN_UPDATE_METRIC(plugin, name, val, grp)                    \
+    plugin->common.adapter_callbacks->update_metric(plugin->common.adapter, \
+                                                    name, val, grp)
+
 extern int64_t global_timestamp;
 
 typedef struct neu_plugin_common {

include/neuron/utils/rolling_counter.h

@@ -0,0 +1,115 @@
+/**
+ * NEURON IIoT System for Industry 4.0
+ * Copyright (C) 2020-2024 EMQ Technologies Co., Ltd All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ **/
+#ifndef NEURON_UTILS_ROLLING_COUNTER_H
+#define NEURON_UTILS_ROLLING_COUNTER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/** Rolling counter.
+ *
+ * This counter is for counting values within some latest time span, like
+ * network bytes sent within the last 5 seconds etc.
+ */
+typedef struct {
+    uint64_t val;      // accumulator
+    uint64_t ts;       // head time stamp in milliseconds
+    uint32_t res : 21; // time resolution in milliseconds
+    uint32_t hd : 5;   // head position
+    uint32_t n : 6;    // number of counters
+    uint32_t counts[]; // bins of counters
+} neu_rolling_counter_t;
+
+/** Create rolling counter.
+ *
+ * @param   span   time span in milliseconds
+ */
+static inline neu_rolling_counter_t *neu_rolling_counter_new(unsigned span)
+{
+    unsigned n = span <= 6000 ? 4 : span <= 32000 ? 8 : span <= 64000 ? 16 : 32;
+    assert(span / n < (1 << 22)); // should not overflow ti
+
+    neu_rolling_counter_t *counter = (neu_rolling_counter_t *) calloc(
+        1, sizeof(*counter) + sizeof(counter->counts[0]) * n);
+    if (counter) {
+        counter->res = span / n;
+        counter->n   = n;
+    }
+    return counter;
+}
+
+/** Destructs the rolling counter.
+ */
+static inline void neu_rolling_counter_free(neu_rolling_counter_t *counter)
+{
+    if (counter) {
+        free(counter);
+    }
+}
+
+/** Increment the rolling counter and return the value;
+ *
+ * @param   ts    time stamp in milliseconds, should be monotonic
+ * @param   dt    delta value to increment by
+ */
+static inline uint64_t neu_rolling_counter_inc(neu_rolling_counter_t *counter,
+                                               uint64_t ts, unsigned dt)
+{
+    uint64_t step = (ts - counter->ts) / counter->res;
+    for (unsigned i = 0; i < step && i < counter->n; ++i) {
+        counter->hd = (counter->hd + 1) & (counter->n - 1);
+        counter->val -= counter->counts[counter->hd];
+        counter->counts[counter->hd] = 0;
+    }
+    counter->val += dt;
+    counter->counts[counter->hd] += dt;
+    counter->ts += step * counter->res;
+    return counter->val;
+}
+
+/** Reset the counter.
+ */
+static inline void neu_rolling_counter_reset(neu_rolling_counter_t *counter)
+{
+    counter->val = 0;
+    counter->hd  = 0;
+    memset(counter->counts, 0, counter->n * sizeof(counter->counts[0]));
+}
+
+/** Return the counter value.
+ *
+ * NOTE: may return stale value if the counter is not updated frequent enough.
+ */
+static inline uint64_t neu_rolling_counter_value(neu_rolling_counter_t *counter)
+{
+    return counter->val;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

persistence/0060_2.7.3_tag_name_length.sql

@@ -0,0 +1,40 @@
+/**
+ * NEURON IIoT System for Industry 4.0
+ * Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ **/
+BEGIN TRANSACTION;
+
+ALTER TABLE tags RENAME TO temp_tags;
+CREATE TABLE IF NOT EXISTS
+  tags (
+    driver_name TEXT NOT NULL,
+    group_name TEXT NOT NULL,
+    name TEXT NULL check(length(name) <= 128),
+    address TEXT NULL check(length(address) <= 128),
+    attribute INTEGER NOT NULL check(attribute BETWEEN 0 AND 15),
+    precision INTEGER NOT NULL check(precision BETWEEN 0 AND 17),
+    decimal REAL NOT NULL,
+    type INTEGER NOT NULL check(type BETWEEN 0 AND 19),
+    description TEXT NULL check(length(description) <= 512),
+    value TEXT,
+    UNIQUE (driver_name, group_name, name),
+    FOREIGN KEY (driver_name, group_name) REFERENCES groups (driver_name, name) ON UPDATE CASCADE ON DELETE CASCADE
+  );
+INSERT INTO tags SELECT * FROM temp_tags;
+
+DROP TABLE temp_tags;
+COMMIT;

plugins/ekuiper/plugin_ekuiper.c

@@ -71,6 +71,10 @@ static void pipe_rm_cb(nng_pipe p, nng_pipe_ev ev, void *arg)
     nng_mtx_lock(plugin->mtx);
     plugin->common.link_state = NEU_NODE_LINK_STATE_DISCONNECTED;
     nng_mtx_unlock(plugin->mtx);
+
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_DISCONNECTION_60S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_DISCONNECTION_600S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_DISCONNECTION_1800S, 1, NULL);
 }
 
 static int ekuiper_plugin_init(neu_plugin_t *plugin, bool load)
@@ -96,6 +100,22 @@ static int ekuiper_plugin_init(neu_plugin_t *plugin, bool load)
 
     plugin->recv_aio = recv_aio;
 
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_TRANS_DATA_5S, 5000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_TRANS_DATA_30S, 30000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_TRANS_DATA_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_SEND_BYTES_5S, 5000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_SEND_BYTES_30S, 30000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_SEND_BYTES_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_BYTES_5S, 5000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_BYTES_30S, 30000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_BYTES_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_MSGS_5S, 5000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_MSGS_30S, 30000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_MSGS_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_DISCONNECTION_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_DISCONNECTION_600S, 600000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_DISCONNECTION_1800S, 1800000);
+
     plog_notice(plugin, "plugin initialized");
     return rv;
 }
@@ -303,6 +323,10 @@ static int ekuiper_plugin_request(neu_plugin_t *      plugin,
     case NEU_REQRESP_TRANS_DATA: {
         neu_reqresp_trans_data_t *trans_data = data;
 
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_TRANS_DATA_5S, 1, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_TRANS_DATA_30S, 1, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_TRANS_DATA_60S, 1, NULL);
+
         if (disconnected) {
             plog_debug(plugin, "not connected");
         } else {

plugins/ekuiper/read_write.c

@@ -30,9 +30,6 @@ void send_data(neu_plugin_t *plugin, neu_reqresp_trans_data_t *trans_data)
 {
     int rv = 0;
 
-    neu_adapter_update_metric_cb_t update_metric =
-        plugin->common.adapter_callbacks->update_metric;
-
     char *           json_str = NULL;
     json_read_resp_t resp     = {
         .plugin     = plugin,
@@ -59,15 +56,18 @@ void send_data(neu_plugin_t *plugin, neu_reqresp_trans_data_t *trans_data)
     rv = nng_sendmsg(plugin->sock, msg,
                      NNG_FLAG_NONBLOCK); // TODO: use aio to send message
     if (0 == rv) {
-        update_metric(plugin->common.adapter, NEU_METRIC_SEND_BYTES, json_len,
-                      NULL);
-        update_metric(plugin->common.adapter, NEU_METRIC_SEND_MSGS_TOTAL, 1,
-                      NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_MSGS_TOTAL, 1, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_BYTES_5S, json_len,
+                                 NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_BYTES_30S, json_len,
+                                 NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_BYTES_60S, json_len,
+                                 NULL);
     } else {
         plog_error(plugin, "nng cannot send msg: %s", nng_strerror(rv));
         nng_msg_free(msg);
-        update_metric(plugin->common.adapter, NEU_METRIC_SEND_MSG_ERRORS_TOTAL,
-                      1, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_MSG_ERRORS_TOTAL, 1,
+                                 NULL);
     }
 }
 
@@ -80,9 +80,6 @@ void recv_data_callback(void *arg)
     char *            json_str = NULL;
     json_write_req_t *req      = NULL;
 
-    neu_adapter_update_metric_cb_t update_metric =
-        plugin->common.adapter_callbacks->update_metric;
-
     rv = nng_aio_result(plugin->recv_aio);
     if (0 != rv) {
         plog_error(plugin, "nng_recv error: %s", nng_strerror(rv));
@@ -93,9 +90,13 @@ void recv_data_callback(void *arg)
     json_str = nng_msg_body(msg);
     json_len = nng_msg_len(msg);
     plog_debug(plugin, "<< %.*s", (int) json_len, json_str);
-    update_metric(plugin->common.adapter, NEU_METRIC_RECV_BYTES, json_len,
-                  NULL);
-    update_metric(plugin->common.adapter, NEU_METRIC_RECV_MSGS_TOTAL, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_TOTAL, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_BYTES_5S, json_len, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_BYTES_30S, json_len, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_BYTES_60S, json_len, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_5S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_30S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_60S, 1, NULL);
     if (json_decode_write_req(json_str, json_len, &req) < 0) {
         plog_error(plugin, "fail decode write request json: %.*s",
                    (int) nng_msg_len(msg), json_str);

plugins/mqtt/mqtt_handle.c

@@ -276,15 +276,14 @@ static void publish_cb(int errcode, neu_mqtt_qos_e qos, char *topic,
 
     neu_plugin_t *plugin = data;
 
-    neu_adapter_update_metric_cb_t update_metric =
-        plugin->common.adapter_callbacks->update_metric;
-
     if (0 == errcode) {
-        update_metric(plugin->common.adapter, NEU_METRIC_SEND_MSGS_TOTAL, 1,
-                      NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_MSGS_TOTAL, 1, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_BYTES_5S, len, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_BYTES_30S, len, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_BYTES_60S, len, NULL);
     } else {
-        update_metric(plugin->common.adapter, NEU_METRIC_SEND_MSG_ERRORS_TOTAL,
-                      1, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_MSG_ERRORS_TOTAL, 1,
+                                 NULL);
     }
 
     free(payload);
@@ -293,16 +292,14 @@ static void publish_cb(int errcode, neu_mqtt_qos_e qos, char *topic,
 static inline int publish(neu_plugin_t *plugin, neu_mqtt_qos_e qos, char *topic,
                           char *payload, size_t payload_len)
 {
-    neu_adapter_update_metric_cb_t update_metric =
-        plugin->common.adapter_callbacks->update_metric;
 
     int rv =
         neu_mqtt_client_publish(plugin->client, qos, topic, (uint8_t *) payload,
                                 (uint32_t) payload_len, plugin, publish_cb);
     if (0 != rv) {
         plog_error(plugin, "pub [%s, QoS%d] fail", topic, qos);
-        update_metric(plugin->common.adapter, NEU_METRIC_SEND_MSG_ERRORS_TOTAL,
-                      1, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_SEND_MSG_ERRORS_TOTAL, 1,
+                                 NULL);
         free(payload);
         rv = NEU_ERR_MQTT_PUBLISH_FAILURE;
     }
@@ -320,9 +317,13 @@ void handle_write_req(neu_mqtt_qos_e qos, const char *topic,
     (void) qos;
     (void) topic;
 
-    neu_adapter_update_metric_cb_t update_metric =
-        plugin->common.adapter_callbacks->update_metric;
-    update_metric(plugin->common.adapter, NEU_METRIC_RECV_MSGS_TOTAL, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_TOTAL, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_BYTES_5S, len, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_BYTES_30S, len, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_BYTES_60S, len, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_5S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_30S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_60S, 1, NULL);
 
     char *json_str = malloc(len + 1);
     if (NULL == json_str) {
@@ -407,9 +408,13 @@ void handle_read_req(neu_mqtt_qos_e qos, const char *topic,
     (void) qos;
     (void) topic;
 
-    neu_adapter_update_metric_cb_t update_metric =
-        plugin->common.adapter_callbacks->update_metric;
-    update_metric(plugin->common.adapter, NEU_METRIC_RECV_MSGS_TOTAL, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_TOTAL, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_BYTES_5S, len, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_BYTES_30S, len, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_BYTES_60S, len, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_5S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_30S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_RECV_MSGS_60S, 1, NULL);
 
     char *json_str = malloc(len + 1);
     if (NULL == json_str) {

plugins/mqtt/mqtt_plugin.c

@@ -37,6 +37,9 @@ static void disconnect_cb(void *data)
 {
     neu_plugin_t *plugin      = data;
     plugin->common.link_state = NEU_NODE_LINK_STATE_DISCONNECTED;
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_DISCONNECTION_60S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_DISCONNECTION_600S, 1, NULL);
+    NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_DISCONNECTION_1800S, 1, NULL);
     plog_notice(plugin, "plugin `%s` disconnected",
                 neu_plugin_module.module_name);
 }
@@ -60,13 +63,26 @@ static int mqtt_plugin_close(neu_plugin_t *plugin)
 static int mqtt_plugin_init(neu_plugin_t *plugin, bool load)
 {
     (void) load;
+
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_CACHED_MSGS_NUM, 0);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_TRANS_DATA_5S, 5000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_TRANS_DATA_30S, 30000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_TRANS_DATA_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_SEND_BYTES_5S, 5000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_SEND_BYTES_30S, 30000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_SEND_BYTES_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_BYTES_5S, 5000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_BYTES_30S, 30000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_BYTES_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_MSGS_5S, 5000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_MSGS_30S, 30000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_RECV_MSGS_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_DISCONNECTION_60S, 60000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_DISCONNECTION_600S, 600000);
+    NEU_PLUGIN_REGISTER_METRIC(plugin, NEU_METRIC_DISCONNECTION_1800S, 1800000);
+
     plog_notice(plugin, "initialize plugin `%s` success",
                 neu_plugin_module.module_name);
-    neu_adapter_register_metric_cb_t register_metric =
-        plugin->common.adapter_callbacks->register_metric;
-    register_metric(plugin->common.adapter, NEU_METRIC_CACHED_MSGS_NUM,
-                    NEU_METRIC_CACHED_MSGS_NUM_HELP,
-                    NEU_METRIC_CACHED_MSGS_NUM_TYPE, 0);
     return NEU_ERR_SUCCESS;
 }
 
@@ -333,15 +349,12 @@ static int mqtt_plugin_request(neu_plugin_t *plugin, neu_reqresp_head_t *head,
 {
     neu_err_code_e error = NEU_ERR_SUCCESS;
 
-    neu_adapter_update_metric_cb_t update_metric =
-        plugin->common.adapter_callbacks->update_metric;
-
     // update cached messages number per seconds
     if (NULL != plugin->client &&
         (global_timestamp - plugin->cache_metric_update_ts) >= 1000) {
-        update_metric(plugin->common.adapter, NEU_METRIC_CACHED_MSGS_NUM,
-                      neu_mqtt_client_get_cached_msgs_num(plugin->client),
-                      NULL);
+        NEU_PLUGIN_UPDATE_METRIC(
+            plugin, NEU_METRIC_CACHED_MSGS_NUM,
+            neu_mqtt_client_get_cached_msgs_num(plugin->client), NULL);
         plugin->cache_metric_update_ts = global_timestamp;
     }
 
@@ -353,6 +366,9 @@ static int mqtt_plugin_request(neu_plugin_t *plugin, neu_reqresp_head_t *head,
         error = handle_read_response(plugin, head->ctx, data);
         break;
     case NEU_REQRESP_TRANS_DATA: {
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_TRANS_DATA_5S, 1, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_TRANS_DATA_30S, 1, NULL);
+        NEU_PLUGIN_UPDATE_METRIC(plugin, NEU_METRIC_TRANS_DATA_60S, 1, NULL);
         error = handle_trans_data(plugin, data);
         break;
     }

plugins/restful/metric_handle.c

@@ -19,8 +19,11 @@
 
 #include <stdio.h>
 
+#include <pthread.h>
+
 #include "define.h"
 #include "metrics.h"
+#include "plugin.h"
 #include "utils/asprintf.h"
 #include "utils/http.h"
 #include "utils/http_handler.h"
@@ -164,8 +167,8 @@ static inline void gen_global_metrics(const neu_metrics_t *metrics,
             metrics->south_running_nodes, metrics->south_disconnected_nodes);
 }
 
-static inline void
-gen_single_node_metrics(const neu_node_metrics_t *node_metrics, FILE *stream)
+static inline void gen_single_node_metrics(neu_node_metrics_t *node_metrics,
+                                           FILE *              stream)
 {
     fprintf(stream,
             "# HELP node_type Driver(1) or APP(2)\n"
@@ -175,8 +178,13 @@ gen_single_node_metrics(const neu_node_metrics_t *node_metrics, FILE *stream)
 
     neu_metric_entry_t *e = NULL;
 
+    pthread_mutex_lock(&node_metrics->lock);
     HASH_LOOP(hh, node_metrics->entries, e)
     {
+        if (NEU_METRIC_TYPE_ROLLING_COUNTER == e->type) {
+            // force clean stale value
+            e->value = neu_rolling_counter_inc(e->rcnt, global_timestamp, 0);
+        }
         fprintf(stream,
                 "# HELP %s %s\n# TYPE %s %s\n%s{node=\"%s\"} %" PRIu64 "\n",
                 e->name, e->help, e->name, neu_metric_type_str(e->type),
@@ -188,6 +196,11 @@ gen_single_node_metrics(const neu_node_metrics_t *node_metrics, FILE *stream)
     {
         HASH_LOOP(hh, g->entries, e)
         {
+            if (NEU_METRIC_TYPE_ROLLING_COUNTER == e->type) {
+                // force clean stale value
+                e->value =
+                    neu_rolling_counter_inc(e->rcnt, global_timestamp, 0);
+            }
             fprintf(stream,
                     "# HELP %s %s\n# TYPE %s %s\n%s{node=\"%s\",group=\"%s\"} "
                     "%" PRIu64 "\n",
@@ -195,6 +208,7 @@ gen_single_node_metrics(const neu_node_metrics_t *node_metrics, FILE *stream)
                     e->name, node_metrics->name, g->name, e->value);
         }
     }
+    pthread_mutex_unlock(&node_metrics->lock);
 }
 
 static inline bool has_entry(neu_node_metrics_t *node_metrics, const char *name)
@@ -216,7 +230,7 @@ static inline bool has_entry(neu_node_metrics_t *node_metrics, const char *name)
     return false;
 }
 
-static void gen_all_node_metrics(const neu_metrics_t *metrics, int type_filter,
+static void gen_all_node_metrics(neu_metrics_t *metrics, int type_filter,
                                  FILE *stream)
 {
     neu_metric_entry_t * e = NULL, *r = NULL;
@@ -261,11 +275,18 @@ static void gen_all_node_metrics(const neu_metrics_t *metrics, int type_filter,
                         r->help, r->name, neu_metric_type_str(r->type));
             }
 
+            pthread_mutex_lock(&n->lock);
             HASH_FIND_STR(n->entries, r->name, e);
             if (e) {
+                if (NEU_METRIC_TYPE_ROLLING_COUNTER == e->type) {
+                    // force clean stale value
+                    e->value =
+                        neu_rolling_counter_inc(e->rcnt, global_timestamp, 0);
+                }
                 fprintf(stream, "%s{node=\"%s\"} %" PRIu64 "\n", e->name,
                         n->name, e->value);
 
+                pthread_mutex_unlock(&n->lock);
                 continue;
             }
 
@@ -273,11 +294,17 @@ static void gen_all_node_metrics(const neu_metrics_t *metrics, int type_filter,
             {
                 HASH_FIND_STR(g->entries, r->name, e);
                 if (e) {
+                    if (NEU_METRIC_TYPE_ROLLING_COUNTER == e->type) {
+                        // force clean stale value
+                        e->value = neu_rolling_counter_inc(e->rcnt,
+                                                           global_timestamp, 0);
+                    }
                     fprintf(stream,
                             "%s{node=\"%s\",group=\"%s\"} %" PRIu64 "\n",
                             e->name, n->name, g->name, e->value);
                 }
             }
+            pthread_mutex_unlock(&n->lock);
         }
     }
 }
@@ -289,7 +316,7 @@ struct context {
     const char *node;
 };
 
-static void gen_node_metrics(const neu_metrics_t *metrics, struct context *ctx)
+static void gen_node_metrics(neu_metrics_t *metrics, struct context *ctx)
 {
     if (ctx->node[0]) {
         neu_node_metrics_t *n = NULL;

src/adapter/adapter.c

@@ -389,22 +389,19 @@ static int adapter_register_metric(neu_adapter_t *adapter, const char *name,
                                    uint64_t init)
 {
     if (NULL == adapter->metrics) {
-        adapter->metrics = calloc(1, sizeof(*adapter->metrics));
+        adapter->metrics =
+            neu_node_metrics_new(adapter, adapter->module->type, adapter->name);
         if (NULL == adapter->metrics) {
             return -1;
         }
-        adapter->metrics->type    = adapter->module->type;
-        adapter->metrics->name    = adapter->name;
-        adapter->metrics->adapter = adapter;
         neu_metrics_add_node(adapter);
     }
 
-    if (0 > neu_metric_entries_add(&adapter->metrics->entries, name, help, type,
-                                   init)) {
+    if (0 >
+        neu_node_metrics_add(adapter->metrics, NULL, name, help, type, init)) {
         return -1;
     }
 
-    neu_metrics_register_entry(name, help, type);
     return 0;
 }
 
@@ -412,47 +409,17 @@ static int adapter_update_metric(neu_adapter_t *adapter,
                                  const char *metric_name, uint64_t n,
                                  const char *group)
 {
-    neu_metric_entry_t *entry = NULL;
     if (NULL == adapter->metrics) {
         return -1;
     }
 
-    if (NULL == group) {
-        HASH_FIND_STR(adapter->metrics->entries, metric_name, entry);
-    } else if (NULL != adapter->metrics->group_metrics) {
-        neu_group_metrics_t *g = NULL;
-        HASH_FIND_STR(adapter->metrics->group_metrics, group, g);
-        if (NULL != g) {
-            HASH_FIND_STR(g->entries, metric_name, entry);
-        }
-    }
-
-    if (NULL == entry) {
-        return -1;
-    }
-
-    if (NEU_METRIC_TYPE_COUNTER == entry->type) {
-        entry->value += n;
-    } else {
-        entry->value = n;
-    }
-
-    return 0;
+    return neu_node_metrics_update(adapter->metrics, group, metric_name, n);
 }
 
-static void adapter_reset_metrics(neu_adapter_t *adapter)
+static inline void adapter_reset_metrics(neu_adapter_t *adapter)
 {
-    neu_metric_entry_t *entry = NULL;
-    if (NULL == adapter->metrics) {
-        return;
-    }
-
-    HASH_LOOP(hh, adapter->metrics->entries, entry) { entry->value = 0; }
-
-    neu_group_metrics_t *g = NULL;
-    HASH_LOOP(hh, adapter->metrics->group_metrics, g)
-    {
-        HASH_LOOP(hh, g->entries, entry) { entry->value = 0; }
+    if (NULL != adapter->metrics) {
+        neu_node_metrics_reset(adapter->metrics);
     }
 }
 
@@ -838,11 +805,13 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         neu_resp_get_node_state_t *resp =
             (neu_resp_get_node_state_t *) &header[1];
 
-        neu_metric_entry_t *e = NULL;
         if (NULL != adapter->metrics) {
+            pthread_mutex_lock(&adapter->metrics->lock);
+            neu_metric_entry_t *e = NULL;
             HASH_FIND_STR(adapter->metrics->entries, NEU_METRIC_LAST_RTT_MS, e);
+            resp->rtt = NULL != e ? e->value : 0;
+            pthread_mutex_unlock(&adapter->metrics->lock);
         }
-        resp->rtt    = NULL != e ? e->value : 0;
         resp->state  = neu_adapter_get_state(adapter);
         header->type = NEU_RESP_GET_NODE_STATE;
         neu_msg_exchange(header);
@@ -1325,8 +1294,8 @@ int add_gtags(neu_adapter_t *adapter, neu_req_add_gtag_t *cmd,
             if (add_tag_result != 0) {
                 for (int added_group_index = 0; added_group_index < group_index;
                      added_group_index++) {
-                    for (int added_tag_index = 0; added_tag_index <=
-                         cmd->groups[added_group_index].n_tag;
+                    for (int added_tag_index = 0;
+                         added_tag_index < cmd->groups[added_group_index].n_tag;
                          added_tag_index++) {
                         neu_adapter_driver_del_tag(
                             (neu_adapter_driver_t *) adapter,
@@ -1368,11 +1337,6 @@ void neu_adapter_destroy(neu_adapter_t *adapter)
 
     if (NULL != adapter->metrics) {
         neu_metrics_del_node(adapter);
-        neu_metric_entry_t *e = NULL;
-        HASH_LOOP(hh, adapter->metrics->entries, e)
-        {
-            neu_metrics_unregister_entry(e->name);
-        }
         neu_node_metrics_free(adapter->metrics);
     }
 
@@ -1567,110 +1531,43 @@ int neu_adapter_register_group_metric(neu_adapter_t *adapter,
                                       const char *help, neu_metric_type_e type,
                                       uint64_t init)
 {
-    neu_group_metrics_t *group_metrics = NULL;
-
     if (NULL == adapter->metrics) {
         return -1;
     }
 
-    if (0 > neu_metrics_register_entry(name, help, type)) {
-        return -1;
-    }
-
-    HASH_FIND_STR(adapter->metrics->group_metrics, group_name, group_metrics);
-    if (NULL == group_metrics) {
-        group_metrics = calloc(1, sizeof(*group_metrics));
-        if (NULL == group_metrics) {
-            return -1;
-        }
-        group_metrics->name = strdup(group_name);
-        if (NULL == group_metrics->name) {
-            free(group_metrics);
-            return -1;
-        }
-        HASH_ADD_STR(adapter->metrics->group_metrics, name, group_metrics);
-    }
-
-    if (0 > neu_metric_entries_add(&group_metrics->entries, name, help, type,
-                                   init)) {
-        return -1;
-    }
-
-    return 0;
+    return neu_node_metrics_add(adapter->metrics, group_name, name, help, type,
+                                init);
 }
 
 int neu_adapter_update_group_metric(neu_adapter_t *adapter,
                                     const char *   group_name,
                                     const char *metric_name, uint64_t n)
 {
-    neu_metric_entry_t * entry         = NULL;
-    neu_group_metrics_t *group_metrics = NULL;
-
     if (NULL == adapter->metrics) {
         return -1;
     }
 
-    HASH_FIND_STR(adapter->metrics->group_metrics, group_name, group_metrics);
-    if (NULL == group_metrics) {
-        return -1;
-    }
-
-    HASH_FIND_STR(group_metrics->entries, metric_name, entry);
-    if (NULL == entry) {
-        return -1;
-    }
-
-    if (NEU_METRIC_TYPE_COUNTER == entry->type) {
-        entry->value += n;
-    } else {
-        entry->value = n;
-    }
-
-    return 0;
+    return neu_node_metrics_update(adapter->metrics, group_name, metric_name,
+                                   n);
 }
 
 int neu_adapter_metric_update_group_name(neu_adapter_t *adapter,
                                          const char *   group_name,
                                          const char *   new_group_name)
 {
-    neu_group_metrics_t *group_metrics = NULL;
-
     if (NULL == adapter->metrics) {
         return -1;
     }
 
-    HASH_FIND_STR(adapter->metrics->group_metrics, group_name, group_metrics);
-    if (NULL == group_metrics) {
-        return -1;
-    }
-
-    char *name = strdup(new_group_name);
-    if (NULL == name) {
-        return -1;
-    }
-
-    HASH_DEL(adapter->metrics->group_metrics, group_metrics);
-    free(group_metrics->name);
-    group_metrics->name = name;
-    HASH_ADD_STR(adapter->metrics->group_metrics, name, group_metrics);
-
-    return 0;
+    return neu_node_metrics_update_group(adapter->metrics, group_name,
+                                         new_group_name);
 }
 
 void neu_adapter_del_group_metrics(neu_adapter_t *adapter,
                                    const char *   group_name)
 {
-    if (NULL == adapter->metrics) {
-        return;
-    }
-
-    neu_group_metrics_t *gm = NULL;
-    HASH_FIND_STR(adapter->metrics->group_metrics, group_name, gm);
-    if (NULL != gm) {
-        HASH_DEL(adapter->metrics->group_metrics, gm);
-        neu_metric_entry_t *e = NULL;
-        HASH_LOOP(hh, gm->entries, e) { neu_metrics_unregister_entry(e->name); }
-        neu_group_metrics_free(gm);
+    if (NULL != adapter->metrics) {
+        neu_node_metrics_del_group(adapter->metrics, group_name);
     }
 }
 

src/adapter/driver/driver.c

@@ -90,6 +90,7 @@ static void read_group(int64_t timestamp, int64_t timeout,
                        neu_driver_cache_t *cache, const char *group,
                        UT_array *tags, UT_array *tag_values);
 static void read_report_group(int64_t timestamp, int64_t timeout,
+                              neu_tag_cache_type_e cache_type,
                               neu_driver_cache_t *cache, const char *group,
                               UT_array *tags, UT_array *tag_values);
 static void update(neu_adapter_t *adapter, const char *group, const char *tag,
@@ -224,8 +225,9 @@ static void update_im(neu_adapter_t *adapter, const char *group,
     data->group  = strdup(group);
     utarray_new(data->tags, neu_resp_tag_value_meta_icd());
 
-    read_report_group(global_timestamp, 0, driver->cache, group, tags,
-                      data->tags);
+    read_report_group(global_timestamp, 0,
+                      neu_adapter_get_tag_cache_type(&driver->adapter),
+                      driver->cache, group, tags, data->tags);
 
     if (utarray_len(data->tags) > 0) {
         group_t *find = NULL;
@@ -1510,6 +1512,7 @@ static int report_callback(void *usr_data)
     read_report_group(global_timestamp,
                       neu_group_get_interval(group->group) *
                           NEU_DRIVER_TAG_CACHE_EXPIRE_TIME,
+                      neu_adapter_get_tag_cache_type(&group->driver->adapter),
                       group->driver->cache, group->name, tags, data->tags);
 
     if (utarray_len(data->tags) > 0) {
@@ -1683,6 +1686,7 @@ static int read_callback(void *usr_data)
 }
 
 static void read_report_group(int64_t timestamp, int64_t timeout,
+                              neu_tag_cache_type_e cache_type,
                               neu_driver_cache_t *cache, const char *group,
                               UT_array *tags, UT_array *tag_values)
 {
@@ -1775,7 +1779,8 @@ static void read_report_group(int64_t timestamp, int64_t timeout,
             break;
         }
 
-        if (!neu_tag_attribute_test(tag, NEU_ATTRIBUTE_STATIC) &&
+        if (cache_type != NEU_TAG_CACHE_TYPE_NEVER &&
+            !neu_tag_attribute_test(tag, NEU_ATTRIBUTE_STATIC) &&
             (timestamp - value.timestamp) > timeout && timeout > 0) {
             if (value.value.type == NEU_TYPE_PTR) {
                 free(value.value.value.ptr.ptr);

src/base/metrics.c

@@ -262,10 +262,19 @@ int neu_metric_entries_add(neu_metric_entry_t **entries, const char *name,
         return -1;
     }
 
-    entry->name  = name;
-    entry->type  = type;
-    entry->help  = help;
-    entry->value = init;
+    if (NEU_METRIC_TYPE_ROLLING_COUNTER == type) {
+        // only allocate rolling counter for nonzero time span
+        if (init > 0 && NULL == (entry->rcnt = neu_rolling_counter_new(init))) {
+            free(entry);
+            return -1;
+        }
+    } else {
+        entry->value = init;
+    }
+
+    entry->name = name;
+    entry->type = type;
+    entry->help = help;
     HASH_ADD_STR(*entries, name, entry);
     return 0;
 }
@@ -302,9 +311,11 @@ int neu_metrics_register_entry(const char *name, const char *help,
     neu_metric_entry_t *e  = NULL;
 
     pthread_rwlock_wrlock(&g_metrics_mtx_);
+    // use `value` field as reference counter, initialize to zero
+    // and we don't need to allocate rolling counter for register entries
     rv = neu_metric_entries_add(&g_metrics_.registered_metrics, name, help,
-                                type, 1);
-    if (1 == rv) {
+                                type, 0);
+    if (-1 != rv) {
         HASH_FIND_STR(g_metrics_.registered_metrics, name, e);
         ++e->value;
         rv = 0;

src/core/manager_internal.c

@@ -698,7 +698,6 @@ int neu_manager_subscribe(neu_manager_t *manager, const char *app,
     // this is not an elegant solution due to the current architecture
     if (params && 0 == strcmp(adapter->module->module_name, "MQTT")) {
         neu_json_elem_t elem = { .name = "topic", .t = NEU_JSON_STR };
-        neu_json_decode((char *) params, 1, &elem);
         neu_parse_param(params, NULL, 1, &elem);
         if (elem.v.val_str && 0 == strlen(elem.v.val_str)) {
             free(elem.v.val_str);

src/main.c

@@ -126,7 +126,6 @@ static int neuron_run(const neu_cli_args_t *args)
 
     signal(SIGINT, sig_handler);
     signal(SIGABRT, sig_handler);
-    signal(SIGSEGV, sig_handler);
     signal(SIGTERM, sig_handler);
     signal(SIGKILL, sig_handler);
 

tests/ft/metrics/test_metrics.py

@@ -92,8 +92,23 @@ class TestMetrics:
             "send_msg_errors_total": (0, {}),
             "recv_msgs_total": (0, {}),
             "cached_msgs": (0, {}),
+            "last_5s_trans_data_msgs": (0, {}),
+            "last_30s_trans_data_msgs": (0, {}),
+            "last_60s_trans_data_msgs": (0, {}),
+            "last_5s_send_bytes": (0, {}),
+            "last_30s_send_bytes": (0, {}),
+            "last_60s_send_bytes": (0, {}),
+            "last_5s_recv_bytes": (0, {}),
+            "last_30s_recv_bytes": (0, {}),
+            "last_60s_recv_bytes": (0, {}),
+            "last_5s_recv_msgs": (0, {}),
+            "last_30s_recv_msgs": (0, {}),
+            "last_60s_recv_msgs": (0, {}),
+            "last_60s_disconnections": (0, {}),
+            "last_600s_disconnections": (0, {}),
+            "last_1800s_disconnections": (0, {}),
         }
-        
+
         assert_metrics(resp.content.decode('utf-8'), expected_metrics)
 
     @description(given="neuron is started",

tests/ft/tag/test_tag.py

@@ -355,4 +355,132 @@ class TestLog:
         assert 2         == response.json()['groups'][1]['tag_count']
         assert 'group_3' == response.json()['groups'][2]['group']
         assert 3000      == response.json()['groups'][2]['interval']
-        assert 2         == response.json()['groups'][2]['tag_count']
+        assert 2         == response.json()['groups'][2]['tag_count']
+
+    @description(given="multiple groups including same name tags in the first group", when="adding", then="add failed")
+    def test_adding_same_name_gtags_first_group(self):
+        response = api.add_gtags(
+            node='modbus-tcp-tag-test', 
+            groups=[
+                {
+                    "group": "group_f",
+                    "interval": 3000,
+                    "tags": [
+                        {
+                            "name": "tag1",
+                            "address": "1!400001",
+                            "attribute": 3,
+                            "type": 3,
+                            "decimal": 0.01
+                        },
+                        {
+                            "name": "tag1",
+                            "address": "1!400002",
+                            "attribute": 3,
+                            "type": 9,
+                            "precision": 3
+                        }
+                    ]
+                },
+                {
+                    "group": "group_s",
+                    "interval": 3000,
+                    "tags": [
+                        {
+                            "name": "tag1",
+                            "address": "1!400001",
+                            "attribute": 3,
+                            "type": 9,
+                            "precision": 3
+                        },
+                        {
+                            "name": "tag2",
+                            "address": "1!400002",
+                            "attribute": 3,
+                            "type": 9,
+                            "precision": 3
+                        }
+                    ]
+                }
+            ]
+        )
+
+        assert 409 == response.status_code
+        assert NEU_ERR_TAG_NAME_CONFLICT == response.json()['error']
+
+    @description(given="multiple groups including same name tags in the second group", when="adding", then="add failed")
+    def test_adding_same_name_gtags_second_group(self):
+        response = api.add_gtags(
+            node='modbus-tcp-tag-test', 
+            groups=[
+                {
+                    "group": "group_f",
+                    "interval": 3000,
+                    "tags": [
+                        {
+                            "name": "tag1",
+                            "address": "1!400001",
+                            "attribute": 3,
+                            "type": 3,
+                            "decimal": 0.01
+                        },
+                        {
+                            "name": "tag2",
+                            "address": "1!400002",
+                            "attribute": 3,
+                            "type": 9,
+                            "precision": 3
+                        }
+                    ]
+                },
+                {
+                    "group": "group_s",
+                    "interval": 3000,
+                    "tags": [
+                        {
+                            "name": "tag1",
+                            "address": "1!400001",
+                            "attribute": 3,
+                            "type": 9,
+                            "precision": 3
+                        },
+                        {
+                            "name": "tag1",
+                            "address": "1!400002",
+                            "attribute": 3,
+                            "type": 9,
+                            "precision": 3
+                        }
+                    ]
+                }
+            ]
+        )
+
+        assert 409 == response.status_code
+        assert NEU_ERR_TAG_NAME_CONFLICT == response.json()['error']
+
+    @description(given="tag name length exceeds 128", when="adding", then="add failed")
+    def test_adding_tag_name_exceeds_128(self):
+        response = api.add_gtags(
+            node='modbus-tcp-tag-test', 
+            groups=[{"group": "group","interval": 3000,
+                     "tags": [{
+                            "name": "Lt7Pa5Q0tKJN2gL3WiYJLnaFzqBq5q5xyJ1vYHxyf2j0IZR7y3RBYxXGQBHwV7dEzD7lIcF1yX9aR3vH8leYxXxHUILk2eVqQBlaQLaROZt9yZ9xQNxKkfy5mySHb79",
+                            "address": "1!400001",
+                            "attribute": 3,
+                            "type": 3,
+                            "decimal": 0.01}]}])
+        assert 200 == response.status_code
+        assert NEU_ERR_SUCCESS == response.json()['error']
+
+        response = api.add_gtags(
+            node='modbus-tcp-tag-test', 
+            groups=[{"group": "group","interval": 3000,
+                     "tags": [{
+                            "name": "Lt7Pa5Q0tKJN2gL3WiYJLnaFzqBq5q5xyJ1vYHxyf2j0IZR7y3RBYxXGQBHwV7dEzD7lIcF1yX9aR3vH8leYxXxHUILk2eVqQBlaQLaROZt9yZ9xQNxKkfy5mySHb79Y8",
+                            "address": "1!400001",
+                            "attribute": 3,
+                            "type": 3,
+                            "decimal": 0.01}]}])
+        assert 400 == response.status_code
+        assert NEU_ERR_TAG_NAME_TOO_LONG == response.json()['error']

tests/ut/CMakeLists.txt

@@ -51,10 +51,18 @@ target_include_directories(modbus_test PRIVATE
 				${CMAKE_SOURCE_DIR}/plugins/modbus)
 target_link_libraries(modbus_test neuron-base gtest_main gtest pthread zlog)
 
+add_executable(rolling_counter_test rolling_counter_test.cc)
+target_include_directories(rolling_counter_test PRIVATE 
+	${CMAKE_SOURCE_DIR}/src
+	${CMAKE_SOURCE_DIR}/include
+)
+target_link_libraries(rolling_counter_test neuron-base gtest_main gtest)
+
 include(GoogleTest)
 gtest_discover_tests(json_test)
 gtest_discover_tests(http_test)
 gtest_discover_tests(jwt_test)
 gtest_discover_tests(base64_test)
 gtest_discover_tests(tag_sort_test)
-gtest_discover_tests(modbus_test)
+gtest_discover_tests(modbus_test)
+gtest_discover_tests(rolling_counter_test)

tests/ut/rolling_counter_test.cc

@@ -0,0 +1,45 @@
+#include <gtest/gtest.h>
+
+#include "utils/log.h"
+#include "utils/rolling_counter.h"
+
+zlog_category_t *neuron = NULL;
+TEST(RollingCounterTest, neu_rolling_counter_inc)
+{
+    uint64_t               ts      = 0;
+    neu_rolling_counter_t *counter = neu_rolling_counter_new(4000);
+    EXPECT_NE(nullptr, counter);
+
+    for (int i = 1; i <= 4; ++i) {
+        ts += 1000;
+        EXPECT_EQ(i, neu_rolling_counter_inc(counter, ts, 1));
+    }
+
+    // wrap around
+    for (int i = 1; i <= 4; ++i) {
+        ts += 1000;
+        EXPECT_EQ(4, neu_rolling_counter_inc(counter, ts, 1));
+    }
+
+    // increment without time stamp update
+    EXPECT_EQ(4, neu_rolling_counter_value(counter));
+    for (int i = 1; i <= 10; ++i) {
+        EXPECT_EQ(4 + i, neu_rolling_counter_inc(counter, ts, 1));
+    }
+
+    EXPECT_EQ(4 + 10, neu_rolling_counter_value(counter));
+
+    // stale value will be clean
+    ts += 4000;
+    EXPECT_EQ(0, neu_rolling_counter_inc(counter, ts, 0));
+
+    neu_rolling_counter_free(counter);
+}
+
+int main(int argc, char **argv)
+{
+    zlog_init("./config/dev.conf");
+    neuron = zlog_get_category("neuron");
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

version

@@ -1 +1 @@
-2.7.2
+2.7.4