Merge pull request #2519 from fengzeroz/v2.11

version: 2.11.4

.github/workflows/check.yml

@@ -9,7 +9,7 @@ on:
 
 jobs:
   clang_format_check:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
 
     steps:
       # checkout
@@ -26,7 +26,8 @@ jobs:
           clangFormatVersion: 10
 
   cppcheck:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
+    container: ghcr.io/neugates/build:x86_64-main
 
     steps:
       - uses: actions/checkout@v4
@@ -35,13 +36,13 @@ jobs:
       
       - name: cppcheck
         run: |
-          sudo apt install cppcheck
+          sudo apt install -y cppcheck
           cppcheck --enable=all  --error-exitcode=2 --inline-suppr --suppress=missingInclude --suppress=unusedFunction --suppress=*:src/otel/trace.pb-c.c --suppress=*:src/otel/common.pb-c.c --suppress=*:src/otel/resource.pb-c.c  ./plugins ./src
           cppcheck --enable=all  --error-exitcode=2 --inline-suppr --suppress=missingInclude  --suppress=variableScope ./simulator
 
   ut:
-    runs-on: ubuntu-20.04
-    container: ghcr.io/neugates/build:x86_64-main
+    runs-on: ubuntu-24.04
+    container: ghcr.io/neugates/build:x86_64-v2.11
 
     steps:
       - uses: actions/checkout@v4
@@ -77,8 +78,8 @@ jobs:
           files: ./cov_report/cov-ut.info
 
   pft:
-    runs-on: ubuntu-20.04
-    container: ghcr.io/neugates/build:x86_64-main
+    runs-on: ubuntu-24.04
+    container: ghcr.io/neugates/build:x86_64-v2.11
     strategy:
       matrix:
         plugin: [core, ekuiper, modbus, mqtt, azure, metrics]

.github/workflows/ci.yml

@@ -8,20 +8,20 @@ on:
       - published
 
 env:
-  VERSION: 2.11.0
+  VERSION: 2.11.4
   UI_VERSION: 2.6.1
-  BRANCH: main
+  BRANCH: v2.11
 
 jobs:
   cross-build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     strategy:
       matrix:
         arch:
           - [aarch64-linux-gnu, aarch64, arm64]
           - [arm-linux-gnueabihf, armv4, armhf]
           - [x86_64-linux-gnu, x86_64, amd64]
-    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-main
+    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-v2.11
 
     steps:
       - uses: actions/checkout@v4
@@ -52,19 +52,19 @@ jobs:
         run: |
           ./package-sdk.sh -p ${{ matrix.arch[2] }} -n neuron-sdk-$VERSION
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
-          name: neuron-sdk
+          name: neuron-sdk-${{ matrix.arch[2] }}
           path: |
             neuron-sdk-*.tar.gz
 
   build-debug-sdk:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     strategy:
       matrix:
         arch:
           - [x86_64-linux-gnu, x86_64, amd64]
-    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-main
+    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-v2.11
 
     steps:
       - uses: actions/checkout@v4
@@ -83,9 +83,9 @@ jobs:
         run: |
           ./package-sdk.sh -p ${{ matrix.arch[2] }} -n neuron-sdk-debug-$VERSION
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
-          name: neuron-sdk
+          name: neuron-sdk-debug
           path: |
             neuron-sdk-debug-*.tar.gz
   
@@ -102,9 +102,19 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: neuron-sdk
+          name: neuron-sdk-debug
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: neuron-sdk-arm64
+      - uses: actions/download-artifact@v4
+        with:
+          name: neuron-sdk-armhf
+      - uses: actions/download-artifact@v4
+        with:
+          name: neuron-sdk-amd64
       
       - uses: softprops/action-gh-release@v1
         env:

cmake/aarch64-linux-gnu.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX aarch64-linux-gnu)
 set(CMAKE_SYSTEM_PROCESSOR aarch64)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.11/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

cmake/arm-linux-gnueabi.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX arm-linux-gnueabi)
 set(CMAKE_SYSTEM_PROCESSOR armv5tejl)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.11/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

cmake/arm-linux-gnueabihf.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX arm-linux-gnueabihf)
 set(CMAKE_SYSTEM_PROCESSOR armv7l)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.11/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

cmake/x86_64-linux-gnu.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX x86_64-linux-gnu)
 set(CMAKE_SYSTEM_PROCESSOR x86_64)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.11/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

include/neuron/define.h

@@ -24,7 +24,7 @@
 
 #define NEU_VERSION_MAJOR 2
 #define NEU_VERSION_MINOR 11
-#define NEU_VERSION_FIX 0
+#define NEU_VERSION_FIX 4
 
 #define NEU_GET_VERSION_MAJOR(V) ((0xffff0000 & V) >> 16)
 #define NEU_GET_VERSION_MINOR(V) ((0x0000ff00 & V) >> 8)
@@ -161,4 +161,8 @@ typedef enum {
 // forward declaration for neu_adapter_t
 typedef struct neu_adapter neu_adapter_t;
 
+typedef struct neu_manager neu_manager_t;
+
+extern neu_manager_t *g_manager;
+
 #endif

include/neuron/json/json.h

@@ -185,6 +185,7 @@ int   neu_json_decode_value(void *object, neu_json_elem_t *ele);
 void *neu_json_encode_new();
 void  neu_json_encode_free(void *json_object);
 void *neu_json_encode_array(void *array, neu_json_elem_t *t, int n);
+void *neu_json_encode_array_ecp(void *array, neu_json_elem_t *t, int n);
 void *neu_json_encode_array_value(void *array, neu_json_elem_t *t, int n);
 int   neu_json_encode_field(void *json_object, neu_json_elem_t *elem, int n);
 int   neu_json_encode(void *json_object, char **str);

include/neuron/msg.h

@@ -326,11 +326,21 @@ typedef struct neu_req_get_node {
     neu_node_type_e type;
     char            plugin[NEU_PLUGIN_NAME_LEN];
     char            node[NEU_NODE_NAME_LEN];
+
+    struct {
+        bool q_state;
+        int  state;
+        bool q_link;
+        int  link;
+        bool s_delay;
+        char q_group_name[NEU_GROUP_NAME_LEN];
+    } query;
 } neu_req_get_node_t;
 
 typedef struct neu_resp_node_info {
-    char node[NEU_NODE_NAME_LEN];
-    char plugin[NEU_PLUGIN_NAME_LEN];
+    int64_t delay;
+    char    node[NEU_NODE_NAME_LEN];
+    char    plugin[NEU_PLUGIN_NAME_LEN];
 } neu_resp_node_info_t;
 
 typedef struct neu_resp_get_node {
@@ -368,6 +378,7 @@ typedef struct neu_req_del_group {
 
 typedef struct neu_req_get_group {
     char driver[NEU_NODE_NAME_LEN];
+    char q_group[NEU_GROUP_NAME_LEN];
 } neu_req_get_group_t;
 
 typedef struct neu_resp_group_info {
@@ -722,10 +733,11 @@ typedef struct neu_resp_tag_value {
 typedef neu_resp_tag_value_t neu_tag_value_t;
 
 typedef struct neu_resp_tag_value_meta {
-    char           tag[NEU_TAG_NAME_LEN];
-    neu_dvalue_t   value;
-    neu_tag_meta_t metas[NEU_TAG_META_SIZE];
-    neu_datatag_t  datatag;
+    char            tag[NEU_TAG_NAME_LEN];
+    neu_dvalue_t    value;
+    neu_tag_meta_t *metas;
+    int             n_meta;
+    neu_datatag_t   datatag;
 } neu_resp_tag_value_meta_t;
 
 static inline UT_icd *neu_resp_tag_value_meta_icd()
@@ -786,10 +798,11 @@ typedef struct {
 } neu_resp_read_group_t;
 
 typedef struct neu_resp_tag_value_meta_paginate {
-    char           tag[NEU_TAG_NAME_LEN];
-    neu_dvalue_t   value;
-    neu_tag_meta_t metas[NEU_TAG_META_SIZE];
-    neu_datatag_t  datatag;
+    char            tag[NEU_TAG_NAME_LEN];
+    neu_dvalue_t    value;
+    neu_tag_meta_t *metas;
+    int             n_meta;
+    neu_datatag_t   datatag;
 } neu_resp_tag_value_meta_paginate_t;
 
 static inline UT_icd *neu_resp_tag_value_meta_paginate_icd()
@@ -816,6 +829,16 @@ static inline void neu_resp_read_free(neu_resp_read_group_t *resp)
     {
         if (tag_value->value.type == NEU_TYPE_PTR) {
             free(tag_value->value.value.ptr.ptr);
+        } else if (NEU_TYPE_ARRAY_CHAR < tag_value->value.type &&
+                   tag_value->value.type < NEU_TYPE_ARRAY_STRING) {
+            free(tag_value->value.value.bools.bools);
+        }
+
+        if (tag_value->metas != NULL) {
+            for (int i = 0; i < tag_value->n_meta; i++) {
+                neu_free_dvalue(&tag_value->metas[i].value);
+            }
+            free(tag_value->metas);
         }
     }
     free(resp->driver);
@@ -830,6 +853,16 @@ neu_resp_read_paginate_free(neu_resp_read_group_paginate_t *resp)
     {
         if (tag_value->value.type == NEU_TYPE_PTR) {
             free(tag_value->value.value.ptr.ptr);
+        } else if (NEU_TYPE_ARRAY_CHAR < tag_value->value.type &&
+                   tag_value->value.type < NEU_TYPE_ARRAY_STRING) {
+            free(tag_value->value.value.bools.bools);
+        }
+
+        if (tag_value->metas != NULL) {
+            for (int i = 0; i < tag_value->n_meta; i++) {
+                neu_free_dvalue(&tag_value->metas[i].value);
+            }
+            free(tag_value->metas);
         }
     }
     free(resp->driver);
@@ -903,6 +936,17 @@ static inline void neu_trans_data_free(neu_reqresp_trans_data_t *data)
                      ++i) {
                     free(tag_value->value.value.strs.strs[i]);
                 }
+                free(tag_value->value.value.strs.strs);
+            } else if (NEU_TYPE_ARRAY_CHAR < tag_value->value.type &&
+                       tag_value->value.type < NEU_TYPE_ARRAY_STRING) {
+                free(tag_value->value.value.bools.bools);
+            }
+
+            if (tag_value->metas != NULL) {
+                for (int i = 0; i < tag_value->n_meta; i++) {
+                    neu_free_dvalue(&tag_value->metas[i].value);
+                }
+                free(tag_value->metas);
             }
         }
         utarray_free(data->tags);
@@ -922,18 +966,21 @@ static inline void neu_tag_value_to_json(neu_resp_tag_value_meta_t *tag_value,
     tag_json->name  = tag_value->tag;
     tag_json->error = 0;
 
-    for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
-        if (strlen(tag_value->metas[k].name) > 0) {
-            tag_json->n_meta++;
-        } else {
-            break;
-        }
-    }
+    // for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
+    //     if (strlen(tag_value->metas[k].name) > 0) {
+    //         tag_json->n_meta++;
+    //     } else {
+    //         break;
+    //     }
+    // }
+
+    tag_json->n_meta = tag_value->n_meta;
+
     if (tag_json->n_meta > 0) {
         tag_json->metas = (neu_json_tag_meta_t *) calloc(
             tag_json->n_meta, sizeof(neu_json_tag_meta_t));
     }
-    neu_json_metas_to_json(tag_value->metas, NEU_TAG_META_SIZE, tag_json);
+    neu_json_metas_to_json(tag_value->metas, tag_value->n_meta, tag_json);
 
     tag_json->datatag.bias = tag_value->datatag.bias;
 
@@ -1131,18 +1178,21 @@ neu_tag_value_to_json_paginate(neu_resp_tag_value_meta_paginate_t *tag_value,
     memcpy(tag_json->datatag.meta, tag_value->datatag.meta,
            NEU_TAG_META_LENGTH);
 
-    for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
-        if (strlen(tag_value->metas[k].name) > 0) {
-            tag_json->n_meta++;
-        } else {
-            break;
-        }
-    }
+    // for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
+    //     if (strlen(tag_value->metas[k].name) > 0) {
+    //         tag_json->n_meta++;
+    //     } else {
+    //         break;
+    //     }
+    // }
+
+    tag_json->n_meta = tag_value->n_meta;
+
     if (tag_json->n_meta > 0) {
         tag_json->metas = (neu_json_tag_meta_t *) calloc(
             tag_json->n_meta, sizeof(neu_json_tag_meta_t));
     }
-    neu_json_metas_to_json_paginate(tag_value->metas, NEU_TAG_META_SIZE,
+    neu_json_metas_to_json_paginate(tag_value->metas, tag_value->n_meta,
                                     tag_json);
 
     switch (tag_value->value.type) {

include/neuron/otel/otel_manager.h

@@ -37,16 +37,21 @@ neu_otel_trace_ctx neu_otel_create_trace(const char *trace_id, void *req_ctx,
                                          const char *tracestate);
 
 neu_otel_trace_ctx neu_otel_find_trace(void *req_ctx);
+neu_otel_trace_ctx neu_otel_find_trace2(void *req_ctx);
 
 void neu_otel_trace_set_final(neu_otel_trace_ctx ctx);
 
 void neu_otel_trace_set_expected_span_num(neu_otel_trace_ctx ctx, uint32_t num);
+void neu_otel_trace_reduce_expected_span_num(neu_otel_trace_ctx ctx,
+                                             uint32_t           num);
 uint8_t *neu_otel_get_trace_id(neu_otel_trace_ctx ctx);
 
 neu_otel_trace_ctx neu_otel_find_trace_by_id(const char *trace_id);
 
 void neu_otel_free_trace(neu_otel_trace_ctx ctx);
 
+void neu_otel_set_internal_parent_span(neu_otel_trace_ctx ctx);
+
 neu_otel_scope_ctx neu_otel_add_span(neu_otel_trace_ctx ctx);
 neu_otel_scope_ctx neu_otel_add_span2(neu_otel_trace_ctx ctx,
                                       const char *       span_name,

include/neuron/plugin.h

@@ -78,6 +78,7 @@ typedef int (*neu_plugin_tag_validator_t)(const neu_datatag_t *tag);
 typedef struct {
     neu_datatag_t *tag;
     neu_value_u    value;
+    neu_type_e     type;
 } neu_plugin_tag_value_t;
 
 typedef struct neu_plugin_intf_funs {

include/neuron/tag.h

@@ -43,6 +43,10 @@ typedef enum {
     NEU_DATATAG_ENDIAN_BL32 = 5, // #BL 2,1,4,3
     NEU_DATATAG_ENDIAN_L64  = 6, // #L  8,7,6,5,4,3,2,1
     NEU_DATATAG_ENDIAN_B64  = 7, // #B  1,2,3,4,5,6,7,8
+    NEU_DATATAG_ENDIAN_LL64 = 8,
+    NEU_DATATAG_ENDIAN_LB64 = 9,
+    NEU_DATATAG_ENDIAN_BB64 = 10,
+    NEU_DATATAG_ENDIAN_BL64 = 11,
 } neu_datatag_endian_e;
 
 typedef enum {
@@ -62,6 +66,7 @@ typedef union {
     } value32;
     struct {
         neu_datatag_endian_e endian;
+        bool                 is_default;
     } value64;
     struct {
         uint16_t                  length;

include/neuron/type.h

@@ -155,7 +155,8 @@ typedef struct {
     uint8_t *  ptr;
 } neu_value_ptr_t;
 
-#define NEU_VALUE_SIZE 128
+#define NEU_VALUE_SIZE 256
+#define NEU_ARRAY_SIZE 128
 
 typedef struct {
     uint8_t bytes[NEU_VALUE_SIZE];
@@ -163,63 +164,63 @@ typedef struct {
 } neu_value_bytes_t;
 
 typedef struct {
-    int8_t  i8s[NEU_VALUE_SIZE];
-    uint8_t length;
+    int8_t * i8s;
+    uint32_t length;
 } neu_value_array_int8_t;
 
 typedef struct {
-    uint8_t u8s[NEU_VALUE_SIZE];
-    uint8_t length;
+    uint8_t *u8s;
+    uint32_t length;
 } neu_value_array_uint8_t;
 
 typedef struct {
-    int16_t i16s[NEU_VALUE_SIZE];
-    uint8_t length;
+    int16_t *i16s;
+    uint32_t length;
 } neu_value_array_int16_t;
 
 typedef struct {
-    uint16_t u16s[NEU_VALUE_SIZE];
-    uint8_t  length;
+    uint16_t *u16s;
+    uint32_t  length;
 } neu_value_array_uint16_t;
 
 typedef struct {
-    int32_t i32s[NEU_VALUE_SIZE];
-    uint8_t length;
+    int32_t *i32s;
+    uint32_t length;
 } neu_value_array_int32_t;
 
 typedef struct {
-    uint32_t u32s[NEU_VALUE_SIZE];
-    uint8_t  length;
+    uint32_t *u32s;
+    uint32_t  length;
 } neu_value_array_uint32_t;
 
 typedef struct {
-    int64_t i64s[NEU_VALUE_SIZE];
-    uint8_t length;
+    int64_t *i64s;
+    uint32_t length;
 } neu_value_array_int64_t;
 
 typedef struct {
-    uint64_t u64s[NEU_VALUE_SIZE];
-    uint8_t  length;
+    uint64_t *u64s;
+    uint32_t  length;
 } neu_value_array_uint64_t;
 
 typedef struct {
-    float   f32s[NEU_VALUE_SIZE];
-    uint8_t length;
+    float *  f32s;
+    uint32_t length;
 } neu_value_array_float_t;
 
 typedef struct {
-    double  f64s[NEU_VALUE_SIZE];
-    uint8_t length;
+    double * f64s;
+    uint32_t length;
 } neu_value_array_double_t;
 
 typedef struct {
-    bool    bools[NEU_VALUE_SIZE];
-    uint8_t length;
+    bool *   bools;
+    uint32_t length;
 } neu_value_array_bool_t;
 
 typedef struct {
-    char *  strs[NEU_VALUE_SIZE];
-    uint8_t length;
+    char **  strs;
+    uint32_t length;
 } neu_value_array_string_t;
 
 typedef union {
@@ -341,6 +342,30 @@ typedef struct {
     neu_value_u value;
     uint8_t     precision;
 } neu_dvalue_t;
+
+static inline void neu_free_dvalue(neu_dvalue_t *dvalue)
+{
+    if (dvalue->type > NEU_TYPE_ARRAY_CHAR &&
+        dvalue->type < NEU_TYPE_ARRAY_STRING) {
+        if (dvalue->value.bools.bools != NULL) {
+            free(dvalue->value.bools.bools);
+            dvalue->value.bools.bools = NULL;
+        }
+    } else if (dvalue->type == NEU_TYPE_ARRAY_STRING) {
+        if (dvalue->value.strs.strs != NULL) {
+            for (uint32_t i = 0; i < dvalue->value.strs.length; i++) {
+                free(dvalue->value.strs.strs[i]);
+            }
+            free(dvalue->value.strs.strs);
+            dvalue->value.strs.strs = NULL;
+        }
+    } else if (dvalue->type == NEU_TYPE_CUSTOM) {
+        if (dvalue->value.json != NULL) {
+            json_decref(dvalue->value.json);
+        }
+    }
+}
+
 typedef union neu_value8 {
     uint8_t value;
     struct {
@@ -865,6 +890,42 @@ static inline uint64_t neu_htonll(uint64_t u)
     return ret;
 }
 
+static inline uint64_t neu_htonlb(uint64_t u)
+{
+    uint8_t *in        = (uint8_t *) &u;
+    uint64_t out       = 0;
+    uint8_t *out_bytes = (uint8_t *) &out;
+
+    out_bytes[0] = in[1];
+    out_bytes[1] = in[0];
+    out_bytes[2] = in[3];
+    out_bytes[3] = in[2];
+    out_bytes[4] = in[5];
+    out_bytes[5] = in[4];
+    out_bytes[6] = in[7];
+    out_bytes[7] = in[6];
+
+    return out;
+}
+
+static inline uint64_t neu_htonbl(uint64_t u)
+{
+    uint8_t *in        = (uint8_t *) &u;
+    uint64_t out       = 0;
+    uint8_t *out_bytes = (uint8_t *) &out;
+
+    out_bytes[0] = in[6];
+    out_bytes[1] = in[7];
+    out_bytes[2] = in[4];
+    out_bytes[3] = in[5];
+    out_bytes[4] = in[2];
+    out_bytes[5] = in[3];
+    out_bytes[6] = in[0];
+    out_bytes[7] = in[1];
+
+    return out;
+}
+
 static inline uint64_t neu_ntohll(uint64_t u)
 {
     return neu_htonll(u);

persistence/0110_2.11.0_tag.sql

@@ -16,21 +16,9 @@
 * 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 groups RENAME TO temp_groups;
+alter TABLE groups add column context TEXT NULL check(length(context) <= 512);
+alter TABLE tags add column format TEXT NULL;
 
-CREATE TABLE IF NOT EXISTS
-  groups (
-    driver_name TEXT NOT NULL,
-    name TEXT NULL check(length(name) <= 32),
-    interval INTEGER NOT NULL check(interval >= 100),
-	context TEXT NULL check(length(context) <= 512),
-    UNIQUE (driver_name, name),
-    FOREIGN KEY (driver_name) REFERENCES nodes (name) ON UPDATE CASCADE ON DELETE CASCADE
-  );
-INSERT INTO groups SELECT driver_name, name, interval, NULL FROM temp_groups;
-
-DROP TABLE temp_groups;
-COMMIT;
+COMMIT;

persistence/0111_2.11.0_sub.sql

@@ -0,0 +1,22 @@
+BEGIN TRANSACTION;
+
+DROP TABLE IF EXISTS temp_subscriptions;
+ALTER TABLE subscriptions RENAME TO temp_subscriptions;
+
+CREATE TABLE
+  IF NOT EXISTS subscriptions (
+    app_name TEXT NOT NULL,
+    driver_name TEXT NOT NULL,
+    group_name TEXT NOT NULL,
+    params TEXT DEFAULT NULL,
+    static_tags TEXT DEFAULT NULL,
+    CHECK (app_name != driver_name),
+    UNIQUE (app_name, driver_name, group_name),
+    FOREIGN KEY (app_name) REFERENCES nodes (name) ON UPDATE CASCADE ON DELETE CASCADE,
+    FOREIGN KEY (driver_name, group_name) REFERENCES groups (driver_name, name) ON UPDATE CASCADE ON DELETE CASCADE
+  );
+INSERT INTO subscriptions SELECT app_name, driver_name, group_name, params, NULL FROM temp_subscriptions;
+
+DROP TABLE temp_subscriptions;
+
+COMMIT;

persistence/0112_2.11.0_tag.sql

@@ -1,76 +0,0 @@
-/**
-* 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.
-**/
-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,
-    bias REAL NOT NULL check (bias BETWEEN -1000 AND 1000),
-    type INTEGER NOT NULL check (type BETWEEN 0 AND 40),
-    description TEXT NULL check (length (description) <= 512),
-    value TEXT,
-    format TEXT NULL,
-    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
-  driver_name,
-  group_name,
-  name,
-  address,
-  attribute,
-  precision,
-  decimal,
-  bias,
-  type,
-  description,
-  NULL,
-  ""
-FROM temp_tags;
-
-DROP TABLE temp_tags;
-
-ALTER TABLE subscriptions RENAME TO temp_subscriptions;
-CREATE TABLE
-  IF NOT EXISTS subscriptions (
-    app_name TEXT NOT NULL,
-    driver_name TEXT NOT NULL,
-    group_name TEXT NOT NULL,
-    params TEXT DEFAULT NULL,
-    static_tags TEXT DEFAULT NULL,
-    CHECK (app_name != driver_name),
-    UNIQUE (app_name, driver_name, group_name),
-    FOREIGN KEY (app_name) REFERENCES nodes (name) ON UPDATE CASCADE ON DELETE CASCADE,
-    FOREIGN KEY (driver_name, group_name) REFERENCES groups (driver_name, name) ON UPDATE CASCADE ON DELETE CASCADE
-  );
-INSERT INTO subscriptions SELECT app_name, driver_name, group_name, params, NULL FROM temp_subscriptions;
-
-DROP TABLE temp_subscriptions;
-
-COMMIT;

persistence/0112_2.12.0_array.sql

@@ -20,6 +20,7 @@ BEGIN TRANSACTION;
 
 ALTER TABLE tags RENAME TO temp_tags;
 
+-- update type integer
 CREATE TABLE
   IF NOT EXISTS tags (
     driver_name TEXT NOT NULL,
@@ -30,31 +31,32 @@ CREATE TABLE
     precision INTEGER NOT NULL check (precision BETWEEN 0 AND 17),
     decimal REAL NOT NULL,
     bias REAL NOT NULL check (bias BETWEEN -1000 AND 1000),
-    type INTEGER NOT NULL check (type BETWEEN 0 AND 40),
+    type INTEGER NOT NULL check (type BETWEEN 0 AND 34 OR type = 40),
     description TEXT NULL check (length (description) <= 512),
     value TEXT,
+    format 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;
+INSERT INTO
+  tags
+SELECT
+  driver_name,
+  group_name,
+  name,
+  address,
+  attribute,
+  PRECISION,
+  decimal,
+  bias,
+  TYPE,
+  description,
+  NULL,
+  format
+FROM
+  temp_tags;
 
 DROP TABLE temp_tags;
 
-ALTER TABLE subscriptions RENAME TO temp_subscriptions;
-CREATE TABLE
-  IF NOT EXISTS subscriptions (
-    app_name TEXT NOT NULL,
-    driver_name TEXT NOT NULL,
-    group_name TEXT NOT NULL,
-    params TEXT DEFAULT NULL,
-    CHECK (app_name != driver_name),
-    UNIQUE (app_name, driver_name, group_name),
-    FOREIGN KEY (app_name) REFERENCES nodes (name) ON UPDATE CASCADE ON DELETE CASCADE,
-    FOREIGN KEY (driver_name, group_name) REFERENCES groups (driver_name, name) ON UPDATE CASCADE ON DELETE CASCADE
-  );
-INSERT INTO subscriptions SELECT * FROM temp_subscriptions;
-
-DROP TABLE temp_subscriptions;
-
-COMMIT;
+COMMIT;

plugins/ekuiper/json_rw.c

@@ -195,10 +195,21 @@ static int decode_write_req_json(void *json_obj, neu_json_write_req_t *req)
             .name = "value",
             .t    = NEU_JSON_VALUE,
         },
+        {
+            .name      = "precision",
+            .t         = NEU_JSON_INT,
+            .attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
+        },
     };
-    ret       = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
+    ret = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
                                   req_elems);
-    req->node = req_elems[0].v.val_str;
+
+    if (req_elems[4].v.val_int > 0) {
+        req_elems[3].t            = NEU_JSON_DOUBLE;
+        req_elems[3].v.val_double = (double_t) req_elems[3].v.val_int;
+    }
+
+    req->node  = req_elems[0].v.val_str;
     req->group = req_elems[1].v.val_str;
     req->tag   = req_elems[2].v.val_str;
     req->t     = req_elems[3].t;
@@ -259,10 +270,21 @@ static int decode_write_tags_req_json(void *                     json_obj,
                 .name = "value",
                 .t    = NEU_JSON_VALUE,
             },
+            {
+                .name      = "precision",
+                .t         = NEU_JSON_INT,
+                .attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
+            },
         };
 
         ret = neu_json_decode_array_by_json(
             json_obj, "tags", i, NEU_JSON_ELEM_SIZE(v_elems), v_elems);
+
+        if (v_elems[2].v.val_int > 0) {
+            v_elems[1].t            = NEU_JSON_DOUBLE;
+            v_elems[1].v.val_double = (double_t) v_elems[1].v.val_int;
+        }
+
         req->tags[i].tag   = v_elems[0].v.val_str;
         req->tags[i].t     = v_elems[1].t;
         req->tags[i].value = v_elems[1].v;

plugins/ekuiper/plugin_ekuiper.c

@@ -316,7 +316,7 @@ static int ekuiper_plugin_request(neu_plugin_t *      plugin,
 
     neu_otel_trace_ctx trace = NULL;
     neu_otel_scope_ctx scope = NULL;
-    if (neu_otel_control_is_started()) {
+    if (neu_otel_control_is_started() && header->ctx) {
         trace = neu_otel_find_trace(header->ctx);
         if (trace) {
             scope = neu_otel_add_span(trace);

plugins/ekuiper/read_write.c

@@ -120,7 +120,8 @@ void send_data(neu_plugin_t *plugin, neu_reqresp_trans_data_t *trans_data)
         nng_msg *msg              = NULL;
         size_t   json_len         = strlen(json_str);
         size_t   trace_header_len = 0;
-        if (neu_otel_data_is_started() && trans_data->trace_ctx) {
+        if (neu_otel_data_is_started() && trans_data->trace_ctx &&
+            trans_trace) {
             trace_header_len = 26;
         }
 
@@ -272,23 +273,26 @@ static int json_value_to_tag_value(union neu_json_value *req,
     case NEU_JSON_ARRAY_BOOL:
         value->type               = NEU_TYPE_ARRAY_BOOL;
         value->value.bools.length = req->val_array_bool.length;
-        for (int i = 0; i < req->val_array_bool.length; i++) {
-            value->value.bools.bools[i] = req->val_array_bool.bools[i];
-        }
+        value->value.bools.bools =
+            calloc(req->val_array_bool.length, sizeof(bool));
+        memcpy(value->value.bools.bools, req->val_array_bool.bools,
+               sizeof(bool) * req->val_array_bool.length);
         break;
     case NEU_JSON_ARRAY_INT64:
         value->type              = NEU_TYPE_ARRAY_INT64;
         value->value.i64s.length = req->val_array_int64.length;
-        for (int i = 0; i < req->val_array_int64.length; i++) {
-            value->value.i64s.i64s[i] = req->val_array_int64.i64s[i];
-        }
+        value->value.i64s.i64s =
+            calloc(req->val_array_int64.length, sizeof(int64_t));
+        memcpy(value->value.i64s.i64s, req->val_array_int64.i64s,
+               sizeof(int64_t) * req->val_array_int64.length);
         break;
     case NEU_JSON_ARRAY_DOUBLE:
         value->type              = NEU_TYPE_ARRAY_DOUBLE;
         value->value.f64s.length = req->val_array_double.length;
-        for (int i = 0; i < req->val_array_double.length; i++) {
-            value->value.f64s.f64s[i] = req->val_array_double.f64s[i];
-        }
+        value->value.f64s.f64s =
+            calloc(req->val_array_double.length, sizeof(double));
+        memcpy(value->value.f64s.f64s, req->val_array_double.f64s,
+               sizeof(double) * req->val_array_double.length);
         break;
     default:
         return -1;

plugins/modbus/modbus-rtu.json

@@ -18,11 +18,11 @@
 		},
 		{
 			"type": 7,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 8,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 9,
@@ -30,7 +30,7 @@
 		},
 		{
 			"type": 10,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 11,
@@ -158,8 +158,8 @@
 		}
 	},
 	"endianess": {
-		"name": "Endianess",
-		"name_zh": "字节序",
+		"name": "Endianess of 4-Byte Data",
+		"name_zh": "4 字节数据字节序",
 		"description": "Tag byte order, ABCD corresponds to 1234",
 		"description_zh": "点位字节序，ABCD 对应 1234",
 		"attribute": "required",
@@ -186,6 +186,35 @@
 			]
 		}
 	},
+	"endianess_64": {
+		"name": "Endianess of 8-Byte Data",
+		"name_zh": "8 字节数据字节序",
+		"description": "Tag byte order, applicable to int64, uint64 and double types",
+		"description_zh": "点位字节序，适用于 int64，uint64 和 double 类型",
+		"attribute": "required",
+		"type": "map",
+		"default": 1,
+		"valid": {
+			"map": [
+				{
+					"key": "12 34 56 78",
+					"value": 1
+				},
+				{
+					"key": "21 43 65 87",
+					"value": 2
+				},
+				{
+					"key": "87 65 43 21",
+					"value": 3
+				},
+				{
+					"key": "78 56 34 12",
+					"value": 4
+				}
+			]
+		}
+	},
 	"address_base": {
 		"name": "Start Address",
 		"name_zh": "开始地址",

plugins/modbus/modbus-tcp.json

@@ -18,11 +18,11 @@
 		},
 		{
 			"type": 7,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 8,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 9,
@@ -30,7 +30,7 @@
 		},
 		{
 			"type": 10,
-			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|)$"
+			"regex": "^[0-9]+![3-4][0-9]+(#B|#L|#BB|#BL|#LL|#LB|)$"
 		},
 		{
 			"type": 11,
@@ -166,8 +166,8 @@
 		}
 	},
 	"endianess": {
-		"name": "Endianess",
-		"name_zh": "字节序",
+		"name": "Endianess of 4-Byte Data",
+		"name_zh": "4 字节数据字节序",
 		"description": "Tag byte order, ABCD corresponds to 1234",
 		"description_zh": "点位字节序，ABCD 对应 1234",
 		"attribute": "required",
@@ -194,6 +194,35 @@
 			]
 		}
 	},
+	"endianess_64": {
+		"name": "Endianess of 8-Byte Data",
+		"name_zh": "8 字节数据字节序",
+		"description": "Tag byte order, applicable to int64, uint64 and double types",
+		"description_zh": "点位字节序，适用于 int64，uint64 和 double 类型",
+		"attribute": "required",
+		"type": "map",
+		"default": 1,
+		"valid": {
+			"map": [
+				{
+					"key": "12 34 56 78",
+					"value": 1
+				},
+				{
+					"key": "21 43 65 87",
+					"value": 2
+				},
+				{
+					"key": "87 65 43 21",
+					"value": 3
+				},
+				{
+					"key": "78 56 34 12",
+					"value": 4
+				}
+			]
+		}
+	},
 	"address_base": {
 		"name": "Start Address",
 		"name_zh": "开始地址",

plugins/modbus/modbus.h

@@ -73,6 +73,13 @@ typedef enum modbus_endianess {
     MODBUS_CDAB = 4,
 } modbus_endianess;
 
+typedef enum modbus_endianess_64 {
+    MODBUS_LL = 1, // 12 34 56 78
+    MODBUS_LB = 2, // 21 43 65 87
+    MODBUS_BB = 3, // 87 65 43 21
+    MODBUS_BL = 4, // 78 56 34 12
+} modbus_endianess_64;
+
 typedef enum modbus_address_base {
     base_0 = 0,
     base_1 = 1,

plugins/modbus/modbus_point.c

@@ -238,7 +238,8 @@ modbus_read_cmd_sort_t *modbus_tag_sort(UT_array *tags, uint16_t max_byte)
 }
 
 int cal_n_byte(int type, neu_value_u *value, neu_datatag_addr_option_u option,
-               modbus_endianess endianess, bool default_tag_endian)
+               modbus_endianess endianess, bool default_tag_endian,
+               modbus_endianess_64 endianess_64, bool default_tag_endian_64)
 {
     int n = 0;
     switch (type) {
@@ -260,6 +261,9 @@ int cal_n_byte(int type, neu_value_u *value, neu_datatag_addr_option_u option,
     case NEU_TYPE_DOUBLE:
     case NEU_TYPE_INT64:
     case NEU_TYPE_UINT64:
+        if (default_tag_endian_64) {
+            modbus_convert_endianess_64(value, endianess_64);
+        }
         n          = sizeof(uint64_t);
         value->u64 = neu_htonll(value->u64);
         break;
@@ -293,8 +297,9 @@ int cal_n_byte(int type, neu_value_u *value, neu_datatag_addr_option_u option,
     return n;
 }
 
-modbus_write_cmd_sort_t *modbus_write_tags_sort(UT_array *       tags,
-                                                modbus_endianess endianess)
+modbus_write_cmd_sort_t *
+modbus_write_tags_sort(UT_array *tags, modbus_endianess endianess,
+                       modbus_endianess_64 endianess_64)
 {
     neu_tag_sort_result_t *result =
         neu_tag_sort(tags, tag_sort_write, tag_cmp_write);
@@ -316,17 +321,18 @@ modbus_write_cmd_sort_t *modbus_write_tags_sort(UT_array *       tags,
         utarray_foreach(result->sorts[i].tags, modbus_point_write_t **, tag_s)
         {
             if ((*tag_s)->point.area == MODBUS_AREA_COIL) {
-                n_byte_tag =
-                    cal_n_byte((*tag_s)->point.type, &(*tag_s)->value,
-                               (*tag_s)->point.option, endianess, true);
+                n_byte_tag = cal_n_byte((*tag_s)->point.type, &(*tag_s)->value,
+                                        (*tag_s)->point.option, endianess, true,
+                                        endianess_64, true);
                 data_bit[k / 8] += ((*tag_s)->value.i8) << k % 8;
                 n_byte += n_byte_tag;
                 k++;
             } else {
-                n_byte_tag =
-                    cal_n_byte((*tag_s)->point.type, &(*tag_s)->value,
-                               (*tag_s)->point.option, endianess,
-                               (*tag_s)->point.option.value32.is_default);
+                n_byte_tag = cal_n_byte(
+                    (*tag_s)->point.type, &(*tag_s)->value,
+                    (*tag_s)->point.option, endianess,
+                    (*tag_s)->point.option.value32.is_default, endianess_64,
+                    (*tag_s)->point.option.value64.is_default);
                 memcpy(sort_result->cmd[i].bytes +
                            2 *
                                ((*tag_s)->point.start_address -
@@ -558,4 +564,24 @@ void modbus_convert_endianess(neu_value_u *value, modbus_endianess endianess)
     default:
         break;
     }
+}
+
+void modbus_convert_endianess_64(neu_value_u *       value,
+                                 modbus_endianess_64 endianess_64)
+{
+    switch (endianess_64) {
+    case MODBUS_LL:
+        break;
+    case MODBUS_BB:
+        value->u64 = neu_htonll(value->u64);
+        break;
+    case MODBUS_LB:
+        value->u64 = neu_htonlb(value->u64);
+        break;
+    case MODBUS_BL:
+        value->u64 = neu_htonbl(value->u64);
+        break;
+    default:
+        break;
+    }
 }

plugins/modbus/modbus_point.h

@@ -81,12 +81,15 @@ typedef struct modbus_write_cmd_sort {
     modbus_write_cmd_t *cmd;
 } modbus_write_cmd_sort_t;
 
-modbus_read_cmd_sort_t * modbus_tag_sort(UT_array *tags, uint16_t max_byte);
-modbus_write_cmd_sort_t *modbus_write_tags_sort(UT_array *       tags,
-                                                modbus_endianess endianess);
-void                     modbus_tag_sort_free(modbus_read_cmd_sort_t *cs);
+modbus_read_cmd_sort_t *modbus_tag_sort(UT_array *tags, uint16_t max_byte);
+modbus_write_cmd_sort_t *
+     modbus_write_tags_sort(UT_array *tags, modbus_endianess endianess,
+                            modbus_endianess_64 endianess_64);
+void modbus_tag_sort_free(modbus_read_cmd_sort_t *cs);
 
 void modbus_convert_endianess(neu_value_u *value, modbus_endianess endianess);
+void modbus_convert_endianess_64(neu_value_u *       value,
+                                 modbus_endianess_64 endianess_64);
 
 #ifdef __cplusplus
 }

plugins/modbus/modbus_req.c

@@ -472,6 +472,10 @@ int modbus_value_handle(void *ctx, uint8_t slave_id, uint16_t n_byte,
             case NEU_TYPE_DOUBLE:
             case NEU_TYPE_INT64:
             case NEU_TYPE_UINT64:
+                if ((*p_tag)->option.value64.is_default) {
+                    modbus_convert_endianess_64(&dvalue.value,
+                                                plugin->endianess_64);
+                }
                 dvalue.value.u64 = neu_ntohll(dvalue.value.u64);
                 break;
             case NEU_TYPE_BIT: {
@@ -729,6 +733,9 @@ static uint8_t convert_value(neu_plugin_t *plugin, neu_value_u *value,
     case NEU_TYPE_DOUBLE:
     case NEU_TYPE_INT64:
     case NEU_TYPE_UINT64:
+        if (tag->option.value64.is_default) {
+            modbus_convert_endianess_64(value, plugin->endianess_64);
+        }
         value->u64 = neu_htonll(value->u64);
         n_byte     = sizeof(uint64_t);
         break;
@@ -821,7 +828,8 @@ int modbus_write_tags(neu_plugin_t *plugin, void *req, UT_array *tags)
 
         utarray_push_back(gtags->tags, &p);
     }
-    gtags->cmd_sort = modbus_write_tags_sort(gtags->tags, plugin->endianess);
+    gtags->cmd_sort = modbus_write_tags_sort(gtags->tags, plugin->endianess,
+                                             plugin->endianess_64);
     for (uint16_t i = 0; i < gtags->cmd_sort->n_cmd; i++) {
         ret = write_modbus_points(plugin, &gtags->cmd_sort->cmd[i], req);
         if (ret <= 0) {

plugins/modbus/modbus_req.h

@@ -40,6 +40,7 @@ struct neu_plugin {
 
     modbus_protocol_e   protocol;
     modbus_endianess    endianess;
+    modbus_endianess_64 endianess_64;
     modbus_address_base address_base;
 
     uint16_t interval;

plugins/modbus/modbus_rtu.c

@@ -178,6 +178,9 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
     neu_json_elem_t address_base = { .name = "address_base",
                                      .t    = NEU_JSON_INT };
 
+    neu_json_elem_t endianess_64 = { .name = "endianess_64",
+                                     .t    = NEU_JSON_INT };
+
     ret = neu_parse_param((char *) config, &err_param, 3, &link, &timeout,
                           &interval);
     if (ret != 0) {
@@ -239,6 +242,12 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
         address_base.v.val_int = base_1;
     }
 
+    ret = neu_parse_param((char *) config, &err_param, 1, &endianess_64);
+    if (ret != 0) {
+        free(err_param);
+        endianess_64.v.val_int = MODBUS_LL;
+    }
+
     param.log              = plugin->common.log;
     plugin->max_retries    = max_retries.v.val_int;
     plugin->retry_interval = retry_interval.v.val_int;
@@ -247,6 +256,7 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
     plugin->degrade_time   = degrade_time.v.val_int;
     plugin->endianess      = endianess.v.val_int;
     plugin->address_base   = address_base.v.val_int;
+    plugin->endianess_64   = endianess_64.v.val_int;
 
     if (link.v.val_int == 0) {
         param.type = NEU_CONN_TTY_CLIENT;

plugins/modbus/modbus_stack.c

@@ -376,21 +376,23 @@ int modbus_stack_read(modbus_stack_t *stack, uint8_t slave_id,
                     trace                    = neu_otel_create_trace(
                         new_trace_id, (void *) (intptr_t) stack->read_seq, 0,
                         trace_state);
-                    scope = neu_otel_add_span(trace);
-                    neu_otel_scope_set_span_name(scope, "driver cmd send");
-                    char new_span_id[36] = { 0 };
-                    neu_otel_new_span_id(new_span_id);
-                    neu_otel_scope_set_span_id(scope, new_span_id);
-                    neu_otel_scope_set_span_flags(scope, 0);
-                    neu_otel_scope_set_span_start_time(scope, ts_start);
+                    if (trace) {
+                        scope = neu_otel_add_span(trace);
+                        neu_otel_scope_set_span_name(scope, "driver cmd send");
+                        char new_span_id[36] = { 0 };
+                        neu_otel_new_span_id(new_span_id);
+                        neu_otel_scope_set_span_id(scope, new_span_id);
+                        neu_otel_scope_set_span_flags(scope, 0);
+                        neu_otel_scope_set_span_start_time(scope, ts_start);
 
-                    neu_otel_scope_add_span_attr_int(scope, "thread id",
-                                                     (int64_t) pthread_self());
+                        neu_otel_scope_add_span_attr_int(
+                            scope, "thread id", (int64_t) pthread_self());
 
-                    neu_otel_scope_add_span_attr_string(
-                        scope, "node",
-                        ((neu_plugin_t *) stack->ctx)->common.name);
-                    neu_otel_scope_set_span_end_time(scope, neu_time_ns());
+                        neu_otel_scope_add_span_attr_string(
+                            scope, "node",
+                            ((neu_plugin_t *) stack->ctx)->common.name);
+                        neu_otel_scope_set_span_end_time(scope, neu_time_ns());
+                    }
                 }
             }
         }

plugins/modbus/modbus_tcp.c

@@ -185,6 +185,8 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
     neu_json_elem_t endianess    = { .name = "endianess", .t = NEU_JSON_INT };
     neu_json_elem_t address_base = { .name = "address_base",
                                      .t    = NEU_JSON_INT };
+    neu_json_elem_t endianess_64 = { .name = "endianess_64",
+                                     .t    = NEU_JSON_INT };
 
     neu_json_elem_t  backup_ip   = { .name      = "backup_host",
                                   .t         = NEU_JSON_STR,
@@ -255,6 +257,12 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
         backup = true;
     }
 
+    ret = neu_parse_param((char *) config, &err_param, 1, &endianess_64);
+    if (ret != 0) {
+        free(err_param);
+        endianess_64.v.val_int = MODBUS_LL;
+    }
+
     param.log              = plugin->common.log;
     param_backup.log       = plugin->common.log;
     plugin->interval       = interval.v.val_int;
@@ -265,6 +273,7 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
     plugin->degrade_cycle  = degrade_cycle.v.val_int;
     plugin->degrade_time   = degrade_time.v.val_int;
     plugin->endianess      = endianess.v.val_int;
+    plugin->endianess_64   = endianess_64.v.val_int;
     plugin->address_base   = address_base.v.val_int;
 
     if (mode.v.val_int == 1) {

plugins/mqtt/azure_iot_plugin.c

@@ -184,6 +184,7 @@ static int azure_parse_config(neu_plugin_t *plugin, const char *setting,
     config->cert                = cert.v.val_str;
     config->key                 = key.v.val_str;
     config->upload_drv_state    = false;
+    config->enable_topic        = true;
 
     plog_notice(plugin, "config MQTT version    : %d", config->version);
     plog_notice(plugin, "config client-id       : %s", config->client_id);

plugins/mqtt/mqtt.json

@@ -56,8 +56,8 @@
 	"format": {
 		"name": "Upload Format",
 		"name_zh": "上报数据格式",
-		"description": "JSON format of the data reported. In Values-format mode, data are split into `values` and `errors` sub objects. In Tags-format mode, tag data are put in a single array. ECP-format is the format for connecting to ECP data storage. Custom format supports user-defined data format. For variable definition specifications, please refer to [https://docs.emqx.com/en/neuronex/latest/configuration/north-apps/mqtt/api.html].",
-		"description_zh": "上报数据的 JSON 格式。在 Values-format 格式下，数据被分为 `values` 和 `errors` 两个子对象。在 Tags-format 格式下，数据被放在一个数组中。 ECP-format 为对接 ECP 数据存储的格式。自定义格式，支持用户自定义上报数据格式，变量定义规范请参考【https://docs.emqx.com/zh/neuronex/latest/configuration/north-apps/mqtt/api.html】。",
+		"description": "JSON format of the data reported. In Values-format mode, data are split into `values` and `errors` sub objects. In Tags-format mode, tag data are put in a single array. ECP-format is the format for connecting to ECP data storage. Custom format supports user-defined data format. For variable definition specifications, please refer to 'https://docs.emqx.com/en/neuronex/latest/configuration/north-apps/mqtt/api.html'.",
+		"description_zh": "上报数据的 JSON 格式。在 Values-format 格式下，数据被分为 `values` 和 `errors` 两个子对象。在 Tags-format 格式下，数据被放在一个数组中。 ECP-format 为对接 ECP 数据存储的格式。自定义格式，支持用户自定义上报数据格式，变量定义规范请参考'https://docs.emqx.com/zh/neuronex/latest/configuration/north-apps/mqtt/api.html'。",
 		"attribute": "required",
 		"type": "map",
 		"default": 0,
@@ -105,6 +105,16 @@
 		"default": true,
 		"valid": {}
 	},
+	"enable_topic": {
+		"name": "Enable driver topic",
+		"name_zh": "启动驱动相关主题",
+		"description": "Subscription driver related topics, including read/req, write/req and action/req.",
+		"description_zh": "是否订阅驱动相关主题，包括 read/req、write/req 和 action/req。",
+		"attribute": "optional",
+		"type": "bool",
+		"default": true,
+		"valid": {}
+	},
 	"write-req-topic": {
 		"name": "Write Request Topic",
 		"name_zh": "写请求主题",
@@ -129,30 +139,6 @@
 			"length": 255
 		}
 	},
-	"driver-action-req-topic": {
-		"name": "Driver Action Request Topic",
-		"name_zh": "驱动执行动作请求主题",
-		"description": "MQTT topic to receive driver action request messages.",
-		"description_zh": "驱动执行动作请求的 MQTT 主题。",
-		"attribute": "required",
-		"type": "string",
-		"default": "/neuron/${random_str}/action/req",
-		"valid": {
-			"length": 255
-		}
-	},
-	"driver-action-resp-topic": {
-		"name": "Driver Action Response Topic",
-		"name_zh": "驱动执行动作响应主题",
-		"description": "MQTT topic to send driver action response messages.",
-		"description_zh": "驱动执行动作响应的 MQTT 主题。",
-		"attribute": "required",
-		"type": "string",
-		"default": "/neuron/${random_str}/action/resp",
-		"valid": {
-			"length": 255
-		}
-	},
 	"upload_drv_state": {
 		"name": "Driver Status Report",
 		"name_zh": "驱动状态上报",

plugins/mqtt/mqtt_config.c

@@ -297,13 +297,19 @@ int mqtt_config_parse(neu_plugin_t *plugin, const char *setting,
                                             .t    = NEU_JSON_INT };
     neu_json_elem_t host                = { .name = "host", .t = NEU_JSON_STR };
     neu_json_elem_t port                = { .name = "port", .t = NEU_JSON_INT };
-    neu_json_elem_t username = { .name = "username", .t = NEU_JSON_STR };
-    neu_json_elem_t password = { .name = "password", .t = NEU_JSON_STR };
-    neu_json_elem_t ssl      = { .name = "ssl", .t = NEU_JSON_BOOL };
-    neu_json_elem_t ca       = { .name = "ca", .t = NEU_JSON_STR };
-    neu_json_elem_t cert     = { .name = "cert", .t = NEU_JSON_STR };
-    neu_json_elem_t key      = { .name = "key", .t = NEU_JSON_STR };
-    neu_json_elem_t keypass  = { .name = "keypass", .t = NEU_JSON_STR };
+    neu_json_elem_t username     = { .name = "username", .t = NEU_JSON_STR };
+    neu_json_elem_t password     = { .name = "password", .t = NEU_JSON_STR };
+    neu_json_elem_t ssl          = { .name = "ssl", .t = NEU_JSON_BOOL };
+    neu_json_elem_t ca           = { .name = "ca", .t = NEU_JSON_STR };
+    neu_json_elem_t cert         = { .name = "cert", .t = NEU_JSON_STR };
+    neu_json_elem_t key          = { .name = "key", .t = NEU_JSON_STR };
+    neu_json_elem_t keypass      = { .name = "keypass", .t = NEU_JSON_STR };
+    neu_json_elem_t enable_topic = {
+        .name       = "enable_topic",
+        .t          = NEU_JSON_BOOL,
+        .v.val_bool = true,
+        .attribute  = NEU_JSON_ATTRIBUTE_OPTIONAL,
+    };
     neu_json_elem_t upload_drv_state = {
         .name       = "upload_drv_state",
         .t          = NEU_JSON_BOOL,
@@ -379,6 +385,11 @@ int mqtt_config_parse(neu_plugin_t *plugin, const char *setting,
         free(schema.v.val_str);
     }
 
+    ret = neu_parse_param(setting, &err_param, 1, &enable_topic);
+    if (0 != ret) {
+        enable_topic.v.val_bool = true; // default to true
+    }
+
     ret = neu_parse_param(setting, &err_param, 2, &driver_action_req_topic,
                           &driver_action_resp_topic);
     if (0 != ret) {
@@ -469,6 +480,7 @@ int mqtt_config_parse(neu_plugin_t *plugin, const char *setting,
     config->client_id                = client_id.v.val_str;
     config->qos                      = qos.v.val_int;
     config->format                   = format.v.val_int;
+    config->enable_topic             = enable_topic.v.val_bool;
     config->write_req_topic          = write_req_topic.v.val_str;
     config->write_resp_topic         = write_resp_topic.v.val_str;
     config->driver_action_req_topic  = driver_action_req_topic.v.val_str;
@@ -496,6 +508,7 @@ int mqtt_config_parse(neu_plugin_t *plugin, const char *setting,
     plog_notice(plugin, "config qos             : %d", config->qos);
     plog_notice(plugin, "config format          : %s",
                 mqtt_upload_format_str(config->format));
+    plog_notice(plugin, "config enable-topic    : %d", config->enable_topic);
     plog_notice(plugin, "config write-req-topic : %s", config->write_req_topic);
     plog_notice(plugin, "config write-resp-topic: %s",
                 config->write_resp_topic);

plugins/mqtt/mqtt_config.h

@@ -56,13 +56,16 @@ static inline const char *mqtt_upload_format_str(mqtt_upload_format_e f)
 }
 
 typedef struct {
-    neu_mqtt_version_e   version;                 // mqtt version
-    char *               client_id;               // client id
-    neu_mqtt_qos_e       qos;                     // message QoS
-    mqtt_upload_format_e format;                  // upload format
-    char *               write_req_topic;         // write request topic
-    char *               write_resp_topic;        // write response topic
-    char *               driver_action_req_topic; // driver action request topic
+    neu_mqtt_version_e   version;   // mqtt version
+    char *               client_id; // client id
+    neu_mqtt_qos_e       qos;       // message QoS
+    mqtt_upload_format_e format;    // upload format
+
+    bool  enable_topic;            // default true
+    char *write_req_topic;         // write request topic
+    char *write_resp_topic;        // write response topic
+    char *driver_action_req_topic; // driver action request topic
+
     char *   driver_action_resp_topic; // driver action response topic
     bool     upload_err;               // Upload tag error code flag
     bool     upload_drv_state;         // upload driver state flag

plugins/mqtt/mqtt_handle.c

@@ -41,15 +41,28 @@ static void to_traceparent(uint8_t *trace_id, char *span_id, char *out)
 }
 
 static int tag_values_to_json(UT_array *tags, mqtt_static_vt_t *s_tags,
-                              size_t n_s_tags, neu_json_read_resp_t *json)
+                              size_t n_s_tags, neu_json_read_resp_t *json,
+                              bool filter_error)
 {
-    int index = 0;
+    int index   = 0;
+    int n_valid = 0;
 
-    if (0 == utarray_len(tags)) {
+    if (filter_error) {
+        utarray_foreach(tags, neu_resp_tag_value_meta_t *, tag_value)
+        {
+            if (tag_value->value.type != NEU_TYPE_ERROR) {
+                n_valid += 1;
+            }
+        }
+    } else {
+        n_valid = utarray_len(tags);
+    }
+
+    if (n_valid == 0) {
         return 0;
     }
 
-    json->n_tag = utarray_len(tags) + n_s_tags;
+    json->n_tag = n_valid + n_s_tags;
     json->tags  = (neu_json_read_resp_tag_t *) calloc(
         json->n_tag, sizeof(neu_json_read_resp_tag_t));
     if (NULL == json->tags) {
@@ -58,8 +71,15 @@ static int tag_values_to_json(UT_array *tags, mqtt_static_vt_t *s_tags,
 
     utarray_foreach(tags, neu_resp_tag_value_meta_t *, tag_value)
     {
-        neu_tag_value_to_json(tag_value, &json->tags[index]);
-        index += 1;
+        if (filter_error) {
+            if (tag_value->value.type != NEU_TYPE_ERROR) {
+                neu_tag_value_to_json(tag_value, &json->tags[index]);
+                index += 1;
+            }
+        } else {
+            neu_tag_value_to_json(tag_value, &json->tags[index]);
+            index += 1;
+        }
     }
 
     if (s_tags != NULL) {
@@ -75,27 +95,6 @@ static int tag_values_to_json(UT_array *tags, mqtt_static_vt_t *s_tags,
     return 0;
 }
 
-void filter_error_tags(neu_reqresp_trans_data_t *data)
-{
-    if (!data || !data->tags) {
-        return;
-    }
-
-    UT_array *filtered_tags;
-    utarray_new(filtered_tags, neu_resp_tag_value_meta_icd());
-
-    neu_resp_tag_value_meta_t *tag_ptr = NULL;
-    while ((tag_ptr = (neu_resp_tag_value_meta_t *) utarray_next(data->tags,
-                                                                 tag_ptr))) {
-        if (tag_ptr->value.type != NEU_TYPE_ERROR) {
-            utarray_push_back(filtered_tags, tag_ptr);
-        }
-    }
-
-    utarray_free(data->tags);
-    data->tags = filtered_tags;
-}
-
 char *generate_upload_json(neu_plugin_t *plugin, neu_reqresp_trans_data_t *data,
                            mqtt_upload_format_e format, mqtt_schema_vt_t *vts,
                            size_t n_vts, mqtt_static_vt_t *s_tags,
@@ -107,29 +106,32 @@ char *generate_upload_json(neu_plugin_t *plugin, neu_reqresp_trans_data_t *data,
                                         .timestamp = global_timestamp };
     neu_json_read_resp_t     json     = { 0 };
 
-    if (!plugin->config.upload_err && skip != NULL) {
-        filter_error_tags(data);
-
-        if (utarray_len(data->tags) == 0) {
-            *skip = true;
-            return NULL;
-        }
-    }
-
     if (format == MQTT_UPLOAD_FORMAT_CUSTOM) {
-        if (0 != tag_values_to_json(data->tags, NULL, 0, &json)) {
+        if (0 !=
+            tag_values_to_json(data->tags, NULL, 0, &json,
+                               !plugin->config.upload_err)) {
             plog_error(plugin, "tag_values_to_json fail");
             return NULL;
         }
     } else {
-        if (0 != tag_values_to_json(data->tags, s_tags, n_s_tags, &json)) {
+        if (0 !=
+            tag_values_to_json(data->tags, s_tags, n_s_tags, &json,
+                               !plugin->config.upload_err)) {
             plog_error(plugin, "tag_values_to_json fail");
             return NULL;
         }
     }
 
-    int ret;
+    if (json.n_tag == 0) {
+        plog_warn(plugin, "driver:%s group:%s, no valid tags", data->driver,
+                  data->group);
+        if (skip != NULL) {
+            *skip = true;
+        }
+        return NULL;
+    }
 
+    int ret;
     switch (format) {
     case MQTT_UPLOAD_FORMAT_VALUES:
         neu_json_encode_with_mqtt(&json, neu_json_encode_read_resp1, &header,
@@ -182,7 +184,7 @@ static char *generate_read_resp_json(neu_plugin_t *         plugin,
     char *               json_str = NULL;
     neu_json_read_resp_t json     = { 0 };
 
-    if (0 != tag_values_to_json(data->tags, NULL, 0, &json)) {
+    if (0 != tag_values_to_json(data->tags, NULL, 0, &json, false)) {
         plog_error(plugin, "tag_values_to_json fail");
         return NULL;
     }
@@ -346,29 +348,34 @@ static int json_value_to_tag_value(union neu_json_value *req,
     case NEU_JSON_ARRAY_BOOL:
         value->type               = NEU_TYPE_ARRAY_BOOL;
         value->value.bools.length = req->val_array_bool.length;
-        for (int i = 0; i < req->val_array_bool.length; i++) {
-            value->value.bools.bools[i] = req->val_array_bool.bools[i];
-        }
-        break;
-    case NEU_JSON_ARRAY_DOUBLE:
-        value->type              = NEU_TYPE_ARRAY_DOUBLE;
-        value->value.f64s.length = req->val_array_double.length;
-        for (int i = 0; i < req->val_array_double.length; i++) {
-            value->value.f64s.f64s[i] = req->val_array_double.f64s[i];
-        }
+        value->value.bools.bools =
+            calloc(req->val_array_bool.length, sizeof(bool));
+        memcpy(value->value.bools.bools, req->val_array_bool.bools,
+               sizeof(bool) * req->val_array_bool.length);
         break;
     case NEU_JSON_ARRAY_INT64:
         value->type              = NEU_TYPE_ARRAY_INT64;
         value->value.i64s.length = req->val_array_int64.length;
-        for (int i = 0; i < req->val_array_int64.length; i++) {
-            value->value.i64s.i64s[i] = req->val_array_int64.i64s[i];
-        }
+        value->value.i64s.i64s =
+            calloc(req->val_array_int64.length, sizeof(int64_t));
+        memcpy(value->value.i64s.i64s, req->val_array_int64.i64s,
+               sizeof(int64_t) * req->val_array_int64.length);
+        break;
+    case NEU_JSON_ARRAY_DOUBLE:
+        value->type              = NEU_TYPE_ARRAY_DOUBLE;
+        value->value.f64s.length = req->val_array_double.length;
+        value->value.f64s.f64s =
+            calloc(req->val_array_double.length, sizeof(double));
+        memcpy(value->value.f64s.f64s, req->val_array_double.f64s,
+               sizeof(double) * req->val_array_double.length);
         break;
     case NEU_JSON_ARRAY_STR:
         value->type              = NEU_TYPE_ARRAY_STRING;
         value->value.strs.length = req->val_array_str.length;
-        for (int i = 0; i < req->val_array_str.length; i++) {
-            value->value.strs.strs[i] = req->val_array_str.p_strs[i];
+        value->value.strs.strs =
+            calloc(req->val_array_str.length, sizeof(char *));
+        for (size_t i = 0; i < req->val_array_str.length; i++) {
+            value->value.strs.strs[i] = strdup(req->val_array_str.p_strs[i]);
         }
         break;
     case NEU_JSON_OBJECT:

plugins/mqtt/mqtt_plugin_intf.c

@@ -333,7 +333,6 @@ int mqtt_plugin_config(neu_plugin_t *plugin, const char *setting)
     int           rv          = 0;
     const char *  plugin_name = neu_plugin_module.module_name;
     mqtt_config_t config      = { 0 };
-    bool          started     = false;
 
     rv = plugin->parse_config(plugin, setting, &config);
     if (0 != rv) {
@@ -341,33 +340,13 @@ int mqtt_plugin_config(neu_plugin_t *plugin, const char *setting)
         return NEU_ERR_NODE_SETTING_INVALID;
     }
 
-    if (NULL == plugin->client) {
-        plugin->client = neu_mqtt_client_new(config.version);
-        if (NULL == plugin->client) {
-            plog_error(plugin, "neu_mqtt_client_new fail");
-            rv = NEU_ERR_EINTERNAL;
-            goto error;
+    if (plugin->client != NULL) {
+        if (neu_mqtt_client_is_open(plugin->client)) {
+            neu_mqtt_client_close(plugin->client);
         }
-    } else if (neu_mqtt_client_is_open(plugin->client)) {
-        started = true;
-        plugin->unsubscribe(plugin, &plugin->config);
-        rv = neu_mqtt_client_close(plugin->client);
-        if (0 != rv) {
-            plog_error(plugin, "neu_mqtt_client_close fail");
-            rv = NEU_ERR_EINTERNAL;
-            goto error;
-        }
-        if (neu_mqtt_client_check_version_change(plugin->client,
-                                                 config.version)) {
-            neu_mqtt_client_free(plugin->client);
-            plugin->client = neu_mqtt_client_new(config.version);
-        }
-    } else if (neu_mqtt_client_check_version_change(plugin->client,
-                                                    config.version)) {
-        // plugin stopped and version changed
         neu_mqtt_client_free(plugin->client);
-        plugin->client = neu_mqtt_client_new(config.version);
     }
+    plugin->client = neu_mqtt_client_new(config.version);
 
     rv = config_mqtt_client(plugin, plugin->client, &config);
     if (0 != rv) {
@@ -375,17 +354,17 @@ int mqtt_plugin_config(neu_plugin_t *plugin, const char *setting)
         goto error;
     }
 
-    if (started) {
-        if (0 != neu_mqtt_client_open(plugin->client)) {
-            plog_error(plugin, "neu_mqtt_client_open fail");
-            rv = NEU_ERR_MQTT_CONNECT_FAILURE;
-            goto error;
-        }
-        if (0 != start_hearbeat_timer(plugin, config.heartbeat_interval)) {
-            plog_error(plugin, "start hearbeat_timer failed");
-            rv = NEU_ERR_EINTERNAL;
-            goto error;
-        }
+    if (0 != neu_mqtt_client_open(plugin->client)) {
+        plog_error(plugin, "neu_mqtt_client_open fail");
+        rv = NEU_ERR_MQTT_CONNECT_FAILURE;
+        goto error;
+    }
+    if (0 != start_hearbeat_timer(plugin, config.heartbeat_interval)) {
+        plog_error(plugin, "start hearbeat_timer failed");
+        rv = NEU_ERR_EINTERNAL;
+        goto error;
+    }
+    if (config.enable_topic) {
         if (0 != (rv = plugin->subscribe(plugin, &config))) {
             goto error;
         }
@@ -429,7 +408,10 @@ int mqtt_plugin_start(neu_plugin_t *plugin)
         goto end;
     }
 
-    rv = plugin->subscribe(plugin, &plugin->config);
+    rv = 0;
+    if (plugin->config.enable_topic) {
+        rv = plugin->subscribe(plugin, &plugin->config);
+    }
 
 end:
     if (0 == rv) {
@@ -445,7 +427,9 @@ end:
 int mqtt_plugin_stop(neu_plugin_t *plugin)
 {
     if (plugin->client) {
-        plugin->unsubscribe(plugin, &plugin->config);
+        if (plugin->config.enable_topic) {
+            plugin->unsubscribe(plugin, &plugin->config);
+        }
         neu_mqtt_client_close(plugin->client);
         plog_notice(plugin, "mqtt client closed");
     }
@@ -474,7 +458,7 @@ int mqtt_plugin_request(neu_plugin_t *plugin, neu_reqresp_head_t *head,
     neu_otel_trace_ctx trace           = NULL;
     neu_otel_scope_ctx scope           = NULL;
     char               new_span_id[36] = { 0 };
-    if (neu_otel_control_is_started()) {
+    if (neu_otel_control_is_started() && head->ctx) {
         trace = neu_otel_find_trace(head->ctx);
         if (trace) {
             scope = neu_otel_add_span(trace);

plugins/mqtt/schema.c

@@ -2,6 +2,80 @@
 
 #include "schema.h"
 
+static int mqtt_schema_parse(json_t *root, mqtt_schema_vt_t **vts,
+                             size_t *vts_len, int deep)
+{
+    *vts_len = 0;
+    *vts     = NULL;
+
+    const char *key   = NULL;
+    json_t *    value = NULL;
+
+    json_object_foreach(root, key, value)
+    {
+        if (json_is_string(value)) {
+            const char *str_val = json_string_value(value);
+            if (str_val == NULL) {
+                return -1;
+            }
+
+            *vts_len += 1;
+            *vts = realloc(*vts, *vts_len * sizeof(mqtt_schema_vt_t));
+            mqtt_schema_vt_t *vt = &(*vts)[*vts_len - 1];
+
+            memset(vt, 0, sizeof(mqtt_schema_vt_t));
+            strcpy(vt->name, key);
+
+            if (strcmp(str_val, "${timestamp}") == 0) {
+                vt->vt = MQTT_SCHEMA_TIMESTAMP;
+            } else if (strcmp(str_val, "${node}") == 0) {
+                vt->vt = MQTT_SCHEMA_NODE_NAME;
+            } else if (strcmp(str_val, "${group}") == 0) {
+                vt->vt = MQTT_SCHEMA_GROUP_NAME;
+            } else if (strcmp(str_val, "${tags}") == 0) {
+                vt->vt = MQTT_SCHEMA_TAGS;
+            } else if (strcmp(str_val, "${static_tags}") == 0) {
+                vt->vt = MQTT_SCHEMA_STATIC_TAGS;
+            } else if (strcmp(str_val, "${tag_values}") == 0) {
+                vt->vt = MQTT_SCHEMA_TAGVALUES;
+            } else if (strcmp(str_val, "${static_tag_values}") == 0) {
+                vt->vt = MQTT_SCHEMA_STATIC_TAGVALUES;
+            } else if (strcmp(str_val, "${tag_error_values}") == 0) {
+                vt->vt = MQTT_SCHEMA_TAG_ERROR_VALUES;
+            } else if (strcmp(str_val, "${tag_errors}") == 0) {
+                vt->vt = MQTT_SCHEMA_TAG_ERRORS;
+            } else {
+                if (str_val[0] == '$' && str_val[1] == '{' &&
+                    str_val[strlen(str_val) - 1] == '}') {
+                    return -1;
+                } else {
+                    vt->vt = MQTT_SCHEMA_UD;
+                    strcpy(vt->ud, str_val);
+                }
+            }
+        } else if (json_is_object(value)) {
+            if (deep >= 3) {
+                return -1;
+            }
+
+            *vts_len += 1;
+            *vts = realloc(*vts, *vts_len * sizeof(mqtt_schema_vt_t));
+            mqtt_schema_vt_t *vt = &(*vts)[*vts_len - 1];
+
+            memset(vt, 0, sizeof(mqtt_schema_vt_t));
+            strcpy(vt->name, key);
+
+            vt->vt = MQTT_SCHEMA_OBJECT;
+            return mqtt_schema_parse(value, &vt->sub_vts, &vt->n_sub_vts,
+                                     deep + 1);
+        } else {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
 int mqtt_schema_validate(const char *schema, mqtt_schema_vt_t **vts,
                          size_t *vts_len)
 {
@@ -10,71 +84,24 @@ int mqtt_schema_validate(const char *schema, mqtt_schema_vt_t **vts,
         return -1;
     }
 
-    *vts_len = 0;
-    *vts     = NULL;
-
-    const char *key   = NULL;
-    json_t *    value = NULL;
-
-    json_object_foreach(root, key, value)
-    {
-        if (!json_is_string(value)) {
-            json_decref(root);
-            if (*vts_len > 0) {
-                free(*vts);
-            }
-            return -1;
-        }
-
-        const char *str_val = json_string_value(value);
-        if (str_val == NULL) {
-            json_decref(root);
-            if (*vts_len > 0) {
-                free(*vts);
-            }
-            return -1;
-        }
-
-        *vts_len += 1;
-        *vts = realloc(*vts, *vts_len * sizeof(mqtt_schema_vt_t));
-        mqtt_schema_vt_t *vt = &(*vts)[*vts_len - 1];
-
-        memset(vt, 0, sizeof(mqtt_schema_vt_t));
-        strcpy(vt->name, key);
-
-        if (strcmp(str_val, "${timestamp}") == 0) {
-            vt->vt = MQTT_SCHEMA_TIMESTAMP;
-        } else if (strcmp(str_val, "${node}") == 0) {
-            vt->vt = MQTT_SCHEMA_NODE_NAME;
-        } else if (strcmp(str_val, "${group}") == 0) {
-            vt->vt = MQTT_SCHEMA_GROUP_NAME;
-        } else if (strcmp(str_val, "${tag_values}") == 0) {
-            vt->vt = MQTT_SCHEMA_TAG_VALUES;
-        } else if (strcmp(str_val, "${static_tags}") == 0) {
-            vt->vt = MQTT_SCHEMA_STATIC_TAG_VALUES;
-        } else if (strcmp(str_val, "${tag_errors}") == 0) {
-            vt->vt = MQTT_SCHEMA_TAG_ERRORS;
-        } else {
-            if (str_val[0] == '$' && str_val[1] == '{' &&
-                str_val[strlen(str_val) - 1] == '}') {
-                json_decref(root);
-                free(*vts);
-                return -1;
-            } else {
-                vt->vt = MQTT_SCHEMA_UD;
-                strcpy(vt->ud, str_val);
-            }
+    int ret = mqtt_schema_parse(root, vts, vts_len, 1);
+    if (ret != 0) {
+        if (*vts != NULL) {
+            free(*vts);
+            *vts = NULL;
         }
+        json_decref(root);
+        return -1;
     }
 
     json_decref(root);
     return 0;
 }
 
-int mqtt_schema_encode(char *driver, char *group, neu_json_read_resp_t *tags,
-                       mqtt_schema_vt_t *vts, size_t n_vts,
-                       mqtt_static_vt_t *s_tags, size_t n_s_tags,
-                       char **result_str)
+static void *schema_encode(char *driver, char *group,
+                           neu_json_read_resp_t *tags, mqtt_schema_vt_t *vts,
+                           size_t n_vts, mqtt_static_vt_t *s_tags,
+                           size_t n_s_tags)
 {
     void *root = neu_json_encode_new();
 
@@ -95,7 +122,7 @@ int mqtt_schema_encode(char *driver, char *group, neu_json_read_resp_t *tags,
             elem.t         = NEU_JSON_STR;
             elem.v.val_str = group;
             break;
-        case MQTT_SCHEMA_TAG_VALUES: {
+        case MQTT_SCHEMA_TAGS: {
             void *values_array = neu_json_array();
 
             neu_json_read_resp_tag_t *p_tag = tags->tags;
@@ -130,7 +157,37 @@ int mqtt_schema_encode(char *driver, char *group, neu_json_read_resp_t *tags,
             elem.v.val_object = values_array;
             break;
         }
-        case MQTT_SCHEMA_STATIC_TAG_VALUES: {
+        case MQTT_SCHEMA_TAGVALUES: {
+            void *values_array = neu_json_encode_new();
+
+            neu_json_read_resp_tag_t *p_tag = tags->tags;
+
+            for (int j = 0; j < tags->n_tag; j++) {
+                neu_json_elem_t tag_elems[1 + NEU_TAG_META_SIZE] = { 0 };
+
+                if (p_tag->error == 0) {
+                    tag_elems[0].name = p_tag->name;
+                    tag_elems[0].t    = p_tag->t;
+                    tag_elems[0].v    = p_tag->value;
+
+                    for (int k = 0; k < p_tag->n_meta; k++) {
+                        tag_elems[1 + k].name = p_tag->metas[k].name;
+                        tag_elems[1 + k].t    = p_tag->metas[k].t;
+                        tag_elems[1 + k].v    = p_tag->metas[k].value;
+                    }
+
+                    neu_json_encode_field(values_array, tag_elems,
+                                          1 + p_tag->n_meta);
+                }
+
+                p_tag++;
+            }
+
+            elem.t            = NEU_JSON_OBJECT;
+            elem.v.val_object = values_array;
+            break;
+        }
+        case MQTT_SCHEMA_STATIC_TAGS: {
             void *static_array = neu_json_array();
 
             for (size_t k = 0; k < n_s_tags; k++) {
@@ -153,6 +210,24 @@ int mqtt_schema_encode(char *driver, char *group, neu_json_read_resp_t *tags,
 
             break;
         }
+        case MQTT_SCHEMA_STATIC_TAGVALUES: {
+            void *static_array = neu_json_encode_new();
+
+            for (size_t k = 0; k < n_s_tags; k++) {
+                neu_json_elem_t tag_elems[1 + NEU_TAG_META_SIZE] = { 0 };
+
+                tag_elems[0].name = s_tags[k].name;
+                tag_elems[0].t    = s_tags[k].jtype;
+                tag_elems[0].v    = s_tags[k].jvalue;
+
+                neu_json_encode_field(static_array, tag_elems, 1);
+            }
+
+            elem.t            = NEU_JSON_OBJECT;
+            elem.v.val_object = static_array;
+
+            break;
+        }
         case MQTT_SCHEMA_TAG_ERRORS: {
             void *errors_array = neu_json_array();
 
@@ -181,15 +256,56 @@ int mqtt_schema_encode(char *driver, char *group, neu_json_read_resp_t *tags,
             elem.v.val_object = errors_array;
             break;
         }
+        case MQTT_SCHEMA_TAG_ERROR_VALUES: {
+            void *errors_array = neu_json_encode_new();
+
+            neu_json_read_resp_tag_t *p_tag = tags->tags;
+
+            for (int k = 0; k < tags->n_tag; k++) {
+                neu_json_elem_t tag_elems[1 + NEU_TAG_META_SIZE] = { 0 };
+
+                if (p_tag->error != 0) {
+                    tag_elems[0].name      = p_tag->name;
+                    tag_elems[0].t         = NEU_JSON_INT;
+                    tag_elems[0].v.val_int = p_tag->error;
+
+                    neu_json_encode_field(errors_array, tag_elems, 1);
+                }
+
+                p_tag++;
+            }
+
+            elem.t            = NEU_JSON_OBJECT;
+            elem.v.val_object = errors_array;
+            break;
+        }
         case MQTT_SCHEMA_UD:
             elem.t         = NEU_JSON_STR;
             elem.v.val_str = vts[i].ud;
             break;
+        case MQTT_SCHEMA_OBJECT: {
+            void *sub_root = schema_encode(driver, group, tags, vts[i].sub_vts,
+                                           vts[i].n_sub_vts, s_tags, n_s_tags);
+            elem.t         = NEU_JSON_OBJECT;
+            elem.v.val_object = sub_root;
+            break;
+        }
         }
 
         neu_json_encode_field(root, &elem, 1);
     }
 
+    return root;
+}
+
+int mqtt_schema_encode(char *driver, char *group, neu_json_read_resp_t *tags,
+                       mqtt_schema_vt_t *vts, size_t n_vts,
+                       mqtt_static_vt_t *s_tags, size_t n_s_tags,
+                       char **result_str)
+{
+    void *root =
+        schema_encode(driver, group, tags, vts, n_vts, s_tags, n_s_tags);
+
     int ret = neu_json_encode(root, result_str);
     neu_json_decode_free(root);
     return ret;

plugins/mqtt/schema.h

@@ -32,20 +32,29 @@ extern "C" {
 #include "plugin.h"
 
 typedef enum {
-    MQTT_SCHEMA_TIMESTAMP         = 0,
-    MQTT_SCHEMA_NODE_NAME         = 1,
-    MQTT_SCHEMA_GROUP_NAME        = 2,
-    MQTT_SCHEMA_TAG_VALUES        = 3,
-    MQTT_SCHEMA_STATIC_TAG_VALUES = 4,
-    MQTT_SCHEMA_TAG_ERRORS        = 5,
-    MQTT_SCHEMA_UD                = 6,
+    MQTT_SCHEMA_TIMESTAMP        = 0,
+    MQTT_SCHEMA_NODE_NAME        = 1,
+    MQTT_SCHEMA_GROUP_NAME       = 2,
+    MQTT_SCHEMA_TAGS             = 3,
+    MQTT_SCHEMA_STATIC_TAGS      = 4,
+    MQTT_SCHEMA_TAGVALUES        = 5,
+    MQTT_SCHEMA_STATIC_TAGVALUES = 6,
+    MQTT_SCHEMA_TAG_ERRORS       = 7,
+    MQTT_SCHEMA_TAG_ERROR_VALUES = 8,
+    MQTT_SCHEMA_UD               = 9,
+    MQTT_SCHEMA_OBJECT           = 10,
 } mqtt_schema_vt_e;
 
-typedef struct {
+typedef struct mqtt_schema_vt mqtt_schema_vt_t;
+typedef struct mqtt_schema_vt {
     char name[128];
 
     mqtt_schema_vt_e vt;
-    char             ud[128];
+
+    char ud[128];
+
+    mqtt_schema_vt_t *sub_vts;
+    size_t            n_sub_vts;
 } mqtt_schema_vt_t;
 
 int mqtt_schema_validate(const char *schema, mqtt_schema_vt_t **vts,

plugins/restful/adapter_handle.c

@@ -145,6 +145,7 @@ void handle_get_adapter(nng_aio *aio)
     int  ret                              = 0;
     char plugin_name[NEU_PLUGIN_NAME_LEN] = { 0 };
     char node_name[NEU_NODE_NAME_LEN]     = { 0 };
+    char group_name[NEU_GROUP_NAME_LEN]   = { 0 };
 
     neu_plugin_t *     plugin    = neu_rest_get_plugin();
     neu_node_type_e    node_type = { 0 };
@@ -173,6 +174,33 @@ void handle_get_adapter(nng_aio *aio)
         strcpy(cmd.node, node_name);
     }
 
+    if (neu_http_get_param_str(aio, "group", group_name, sizeof(group_name)) >
+        0) {
+        strcpy(cmd.query.q_group_name, group_name);
+    }
+
+    uintmax_t query_state = 0;
+    if (neu_http_get_param_uintmax(aio, "state", &query_state) == 0) {
+        if (query_state == 1 || query_state == 2 || query_state == 3 ||
+            query_state == 4) {
+            cmd.query.q_state = true;
+            cmd.query.state   = (int) query_state;
+        }
+    }
+
+    uintmax_t query_link = 0;
+    if (neu_http_get_param_uintmax(aio, "link", &query_link) == 0) {
+        if (query_link == 0 || query_link == 1) {
+            cmd.query.q_link = true;
+            cmd.query.link   = (int) query_link;
+        }
+    }
+
+    uintmax_t sort_delay = 0;
+    if (neu_http_get_param_uintmax(aio, "delay", &sort_delay) == 0) {
+        cmd.query.s_delay = true;
+    }
+
     cmd.type = node_type;
     ret      = neu_plugin_op(plugin, header, &cmd);
     if (ret != 0) {

plugins/restful/group_config_handle.c

@@ -160,11 +160,12 @@ void handle_del_group_config(nng_aio *aio)
 
 void handle_get_group_config(nng_aio *aio)
 {
-    neu_plugin_t *      plugin                       = neu_rest_get_plugin();
-    char                node_name[NEU_NODE_NAME_LEN] = { 0 };
-    int                 ret                          = 0;
-    neu_req_get_group_t cmd                          = { 0 };
-    neu_reqresp_head_t  header                       = {
+    neu_plugin_t *      plugin                         = neu_rest_get_plugin();
+    char                node_name[NEU_NODE_NAME_LEN]   = { 0 };
+    char                group_name[NEU_GROUP_NAME_LEN] = { 0 };
+    int                 ret                            = 0;
+    neu_req_get_group_t cmd                            = { 0 };
+    neu_reqresp_head_t  header                         = {
         .ctx             = aio,
         .type            = NEU_REQ_GET_GROUP,
         .otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM,
@@ -178,6 +179,11 @@ void handle_get_group_config(nng_aio *aio)
         header.type = NEU_REQ_GET_DRIVER_GROUP;
     }
 
+    if (neu_http_get_param_str(aio, "group", group_name, sizeof(group_name)) >
+        0) {
+        strcpy(cmd.q_group, group_name);
+    }
+
     ret = neu_plugin_op(plugin, header, &cmd);
     if (ret != 0) {
         NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {

plugins/restful/normal_handle.c

@@ -558,8 +558,8 @@ void handle_get_plugin_schema_resp(nng_aio *aio, neu_resp_check_schema_t *resp)
         size_t len         = 0;
         char * buf         = NULL;
 
-        if (0 > neu_asprintf(&schema_path, "%s/schema/%s.json", g_plugin_dir,
-                             resp->schema)) {
+        if (0 > neu_asprintf(&schema_path, "%s/system/schema/%s.json",
+                             g_plugin_dir, resp->schema)) {
             NEU_JSON_RESPONSE_ERROR(NEU_ERR_EINTERNAL, {
                 neu_http_response(aio, error_code.error, result_error);
             });
@@ -581,7 +581,7 @@ void handle_get_plugin_schema_resp(nng_aio *aio, neu_resp_check_schema_t *resp)
 
         if (NULL == buf) {
             free(schema_path);
-            if (0 > neu_asprintf(&schema_path, "%s/system/schema/%s.json",
+            if (0 > neu_asprintf(&schema_path, "%s/schema/%s.json",
                                  g_plugin_dir, resp->schema)) {
                 NEU_JSON_RESPONSE_ERROR(NEU_ERR_EINTERNAL, {
                     neu_http_response(aio, error_code.error, result_error);

plugins/restful/rest.c

@@ -177,7 +177,7 @@ static int dashb_plugin_request(neu_plugin_t *      plugin,
 
     neu_otel_trace_ctx trace = NULL;
     neu_otel_scope_ctx scope = NULL;
-    if (neu_otel_control_is_started()) {
+    if (neu_otel_control_is_started() && header->ctx) {
         trace = neu_otel_find_trace(header->ctx);
         if (trace) {
             scope = neu_otel_add_span(trace);

plugins/restful/rw_handle.c

@@ -231,39 +231,42 @@ void handle_write(nng_aio *aio)
                     neu_otel_split_traceparent(trace_parent, trace_id, span_id,
                                                &flags);
                     if (strlen(trace_id) == 32) {
-                        trace_flag = true;
-                        trace      = neu_otel_create_trace(trace_id, header.ctx,
+                        trace = neu_otel_create_trace(trace_id, header.ctx,
                                                       flags, trace_state);
-                        scope      = neu_otel_add_span(trace);
-                        neu_otel_scope_set_span_name(
-                            scope, nng_http_req_get_uri(nng_req));
-                        char new_span_id[36] = { 0 };
-                        neu_otel_new_span_id(new_span_id);
-                        neu_otel_scope_set_span_id(scope, new_span_id);
-                        if (strlen(span_id) == 16) {
-                            neu_otel_scope_set_parent_span_id(scope, span_id);
-                        }
-                        neu_otel_scope_set_span_flags(scope, flags);
-                        neu_otel_scope_set_span_start_time(scope,
-                                                           neu_time_ns());
+                        if (trace) {
+                            trace_flag = true;
+                            scope      = neu_otel_add_span(trace);
+                            neu_otel_scope_set_span_name(
+                                scope, nng_http_req_get_uri(nng_req));
+                            char new_span_id[36] = { 0 };
+                            neu_otel_new_span_id(new_span_id);
+                            neu_otel_scope_set_span_id(scope, new_span_id);
+                            if (strlen(span_id) == 16) {
+                                neu_otel_scope_set_parent_span_id(scope,
+                                                                  span_id);
+                            }
+                            neu_otel_scope_set_span_flags(scope, flags);
+                            neu_otel_scope_set_span_start_time(scope,
+                                                               neu_time_ns());
 
-                        neu_otel_scope_add_span_attr_int(
-                            scope, "thread id", (int64_t) pthread_self());
+                            neu_otel_scope_add_span_attr_int(
+                                scope, "thread id", (int64_t) pthread_self());
 
-                        neu_otel_scope_add_span_attr_string(
-                            scope, "HTTP method",
-                            nng_http_req_get_method(nng_req));
-
-                        char * req_data      = NULL;
-                        size_t req_data_size = 0;
-
-                        if (neu_http_get_body((aio), (void **) &req_data,
-                                              &req_data_size) == 0) {
                             neu_otel_scope_add_span_attr_string(
-                                scope, "HTTP body", req_data);
-                        }
+                                scope, "HTTP method",
+                                nng_http_req_get_method(nng_req));
 
-                        free(req_data);
+                            char * req_data      = NULL;
+                            size_t req_data_size = 0;
+
+                            if (neu_http_get_body((aio), (void **) &req_data,
+                                                  &req_data_size) == 0) {
+                                neu_otel_scope_add_span_attr_string(
+                                    scope, "HTTP body", req_data);
+                            }
+
+                            free(req_data);
+                        }
                     }
                 }
             }
@@ -283,21 +286,6 @@ void handle_write(nng_aio *aio)
                 return;
             }
 
-            if (req->t == NEU_JSON_ARRAY_INT64 &&
-                req->value.val_array_int64.length > NEU_VALUE_SIZE) {
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_STRING_TOO_LONG, {
-                    neu_http_response(aio, NEU_ERR_STRING_TOO_LONG,
-                                      result_error);
-                });
-                if (neu_otel_control_is_started() && trace_flag) {
-                    neu_otel_scope_set_status_code2(
-                        scope, NEU_OTEL_STATUS_ERROR, NEU_ERR_STRING_TOO_LONG);
-                    neu_otel_scope_set_span_end_time(scope, neu_time_ns());
-                    neu_otel_trace_set_final(trace);
-                }
-                return;
-            }
-
             if (req->node && strlen(req->node) >= NEU_NODE_NAME_LEN) {
                 err_type = NEU_ERR_NODE_NAME_TOO_LONG;
                 goto error;
@@ -341,7 +329,9 @@ void handle_write(nng_aio *aio)
             case NEU_JSON_ARRAY_INT64:
                 cmd.value.type              = NEU_TYPE_ARRAY_INT64;
                 cmd.value.value.i64s.length = req->value.val_array_int64.length;
-                for (int i = 0; i < req->value.val_array_int64.length; i++) {
+                cmd.value.value.i64s.i64s =
+                    calloc(req->value.val_array_int64.length, sizeof(int64_t));
+                for (size_t i = 0; i < req->value.val_array_int64.length; i++) {
                     cmd.value.value.i64s.i64s[i] =
                         req->value.val_array_int64.i64s[i];
                 }
@@ -350,7 +340,10 @@ void handle_write(nng_aio *aio)
                 cmd.value.type = NEU_TYPE_ARRAY_DOUBLE;
                 cmd.value.value.f64s.length =
                     req->value.val_array_double.length;
-                for (int i = 0; i < req->value.val_array_double.length; i++) {
+                cmd.value.value.f64s.f64s =
+                    calloc(req->value.val_array_double.length, sizeof(double));
+                for (size_t i = 0; i < req->value.val_array_double.length;
+                     i++) {
                     cmd.value.value.f64s.f64s[i] =
                         req->value.val_array_double.f64s[i];
                 }
@@ -358,7 +351,9 @@ void handle_write(nng_aio *aio)
             case NEU_JSON_ARRAY_BOOL:
                 cmd.value.type               = NEU_TYPE_ARRAY_BOOL;
                 cmd.value.value.bools.length = req->value.val_array_bool.length;
-                for (int i = 0; i < req->value.val_array_bool.length; i++) {
+                cmd.value.value.bools.bools =
+                    calloc(req->value.val_array_bool.length, sizeof(bool));
+                for (size_t i = 0; i < req->value.val_array_bool.length; i++) {
                     cmd.value.value.bools.bools[i] =
                         req->value.val_array_bool.bools[i];
                 }
@@ -366,9 +361,11 @@ void handle_write(nng_aio *aio)
             case NEU_JSON_ARRAY_STR:
                 cmd.value.type              = NEU_TYPE_ARRAY_STRING;
                 cmd.value.value.strs.length = req->value.val_array_str.length;
-                for (int i = 0; i < req->value.val_array_str.length; i++) {
+                cmd.value.value.strs.strs =
+                    calloc(req->value.val_array_str.length, sizeof(char *));
+                for (size_t i = 0; i < req->value.val_array_str.length; i++) {
                     cmd.value.value.strs.strs[i] =
-                        req->value.val_array_str.p_strs[i];
+                        strdup(req->value.val_array_str.p_strs[i]);
                 }
                 break;
             case NEU_JSON_OBJECT:
@@ -448,39 +445,42 @@ void handle_write_tags(nng_aio *aio)
                     neu_otel_split_traceparent(trace_parent, trace_id, span_id,
                                                &flags);
                     if (strlen(trace_id) == 32) {
-                        trace_flag = true;
-                        trace      = neu_otel_create_trace(trace_id, header.ctx,
+                        trace = neu_otel_create_trace(trace_id, header.ctx,
                                                       flags, trace_state);
-                        scope      = neu_otel_add_span(trace);
-                        neu_otel_scope_set_span_name(
-                            scope, nng_http_req_get_uri(nng_req));
-                        char new_span_id[36] = { 0 };
-                        neu_otel_new_span_id(new_span_id);
-                        neu_otel_scope_set_span_id(scope, new_span_id);
-                        if (strlen(span_id) == 16) {
-                            neu_otel_scope_set_parent_span_id(scope, span_id);
-                        }
-                        neu_otel_scope_set_span_flags(scope, flags);
-                        neu_otel_scope_set_span_start_time(scope,
-                                                           neu_time_ns());
+                        if (trace) {
+                            trace_flag = true;
+                            scope      = neu_otel_add_span(trace);
+                            neu_otel_scope_set_span_name(
+                                scope, nng_http_req_get_uri(nng_req));
+                            char new_span_id[36] = { 0 };
+                            neu_otel_new_span_id(new_span_id);
+                            neu_otel_scope_set_span_id(scope, new_span_id);
+                            if (strlen(span_id) == 16) {
+                                neu_otel_scope_set_parent_span_id(scope,
+                                                                  span_id);
+                            }
+                            neu_otel_scope_set_span_flags(scope, flags);
+                            neu_otel_scope_set_span_start_time(scope,
+                                                               neu_time_ns());
 
-                        neu_otel_scope_add_span_attr_int(
-                            scope, "thread id", (int64_t) pthread_self());
+                            neu_otel_scope_add_span_attr_int(
+                                scope, "thread id", (int64_t) pthread_self());
 
-                        neu_otel_scope_add_span_attr_string(
-                            scope, "HTTP method",
-                            nng_http_req_get_method(nng_req));
-
-                        char * req_data      = NULL;
-                        size_t req_data_size = 0;
-
-                        if (neu_http_get_body((aio), (void **) &req_data,
-                                              &req_data_size) == 0) {
                             neu_otel_scope_add_span_attr_string(
-                                scope, "HTTP body", req_data);
-                        }
+                                scope, "HTTP method",
+                                nng_http_req_get_method(nng_req));
 
-                        free(req_data);
+                            char * req_data      = NULL;
+                            size_t req_data_size = 0;
+
+                            if (neu_http_get_body((aio), (void **) &req_data,
+                                                  &req_data_size) == 0) {
+                                neu_otel_scope_add_span_attr_string(
+                                    scope, "HTTP body", req_data);
+                            }
+
+                            free(req_data);
+                        }
                     }
                 }
             }
@@ -546,40 +546,48 @@ void handle_write_tags(nng_aio *aio)
                     cmd.tags[i].value.type = NEU_TYPE_ARRAY_INT64;
                     cmd.tags[i].value.value.i64s.length =
                         req->tags[i].value.val_array_int64.length;
-                    for (int k = 0;
-                         k < req->tags[i].value.val_array_int64.length; k++) {
-                        cmd.tags[i].value.value.i64s.i64s[k] =
-                            req->tags[i].value.val_array_int64.i64s[k];
-                    }
+                    cmd.tags[i].value.value.i64s.i64s =
+                        calloc(req->tags[i].value.val_array_int64.length,
+                               sizeof(int64_t));
+                    memcpy(cmd.tags[i].value.value.i64s.i64s,
+                           req->tags[i].value.val_array_int64.i64s,
+                           sizeof(int64_t) *
+                               req->tags[i].value.val_array_int64.length);
                     break;
                 case NEU_JSON_ARRAY_DOUBLE:
                     cmd.tags[i].value.type = NEU_TYPE_ARRAY_DOUBLE;
                     cmd.tags[i].value.value.f64s.length =
                         req->tags[i].value.val_array_double.length;
-                    for (int k = 0;
-                         k < req->tags[i].value.val_array_double.length; k++) {
-                        cmd.tags[i].value.value.f64s.f64s[k] =
-                            req->tags[i].value.val_array_double.f64s[k];
-                    }
+                    cmd.tags[i].value.value.f64s.f64s =
+                        calloc(req->tags[i].value.val_array_double.length,
+                               sizeof(double));
+                    memcpy(cmd.tags[i].value.value.f64s.f64s,
+                           req->tags[i].value.val_array_double.f64s,
+                           sizeof(double) *
+                               req->tags[i].value.val_array_double.length);
                     break;
                 case NEU_JSON_ARRAY_BOOL:
                     cmd.tags[i].value.type = NEU_TYPE_ARRAY_BOOL;
                     cmd.tags[i].value.value.bools.length =
                         req->tags[i].value.val_array_bool.length;
-                    for (int k = 0;
-                         k < req->tags[i].value.val_array_bool.length; k++) {
-                        cmd.tags[i].value.value.bools.bools[k] =
-                            req->tags[i].value.val_array_bool.bools[k];
-                    }
+                    cmd.tags[i].value.value.bools.bools = calloc(
+                        req->tags[i].value.val_array_bool.length, sizeof(bool));
+                    memcpy(cmd.tags[i].value.value.bools.bools,
+                           req->tags[i].value.val_array_bool.bools,
+                           sizeof(bool) *
+                               req->tags[i].value.val_array_bool.length);
                     break;
                 case NEU_JSON_ARRAY_STR:
                     cmd.tags[i].value.type = NEU_TYPE_ARRAY_STRING;
                     cmd.tags[i].value.value.strs.length =
                         req->tags[i].value.val_array_str.length;
-                    for (int k = 0; k < req->tags[i].value.val_array_str.length;
-                         k++) {
+                    cmd.tags[i].value.value.strs.strs =
+                        calloc(req->tags[i].value.val_array_str.length,
+                               sizeof(char *));
+                    for (size_t k = 0;
+                         k < req->tags[i].value.val_array_str.length; k++) {
                         cmd.tags[i].value.value.strs.strs[k] =
-                            req->tags[i].value.val_array_str.p_strs[k];
+                            strdup(req->tags[i].value.val_array_str.p_strs[k]);
                     }
                     break;
                 case NEU_JSON_OBJECT:
@@ -669,34 +677,66 @@ static void trans(neu_json_write_gtags_req_t *req, neu_req_write_gtags_t *cmd)
                 cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_INT64;
                 cmd->groups[i].tags[k].value.value.i64s.length =
                     req->groups[i].tags[k].value.val_array_int64.length;
-                for (int j = 0;
-                     j < req->groups[i].tags[k].value.val_array_int64.length;
-                     j++) {
-                    cmd->groups[i].tags[k].value.value.i64s.i64s[j] =
-                        req->groups[i].tags[k].value.val_array_int64.i64s[j];
-                }
+
+                cmd->groups[i].tags[k].value.value.i64s.i64s =
+                    calloc(sizeof(int64_t),
+                           req->groups[i].tags[k].value.val_array_int64.length);
+
+                memcpy(cmd->groups[i].tags[k].value.value.i64s.i64s,
+                       req->groups[i].tags[k].value.val_array_int64.i64s,
+                       sizeof(int64_t) *
+                           req->groups[i].tags[k].value.val_array_int64.length);
+
                 break;
             case NEU_JSON_ARRAY_DOUBLE:
                 cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_DOUBLE;
                 cmd->groups[i].tags[k].value.value.f64s.length =
                     req->groups[i].tags[k].value.val_array_double.length;
-                for (int j = 0;
-                     j < req->groups[i].tags[k].value.val_array_double.length;
-                     j++) {
-                    cmd->groups[i].tags[k].value.value.f64s.f64s[j] =
-                        req->groups[i].tags[k].value.val_array_double.f64s[j];
-                }
+
+                cmd->groups[i].tags[k].value.value.f64s.f64s = calloc(
+                    sizeof(double),
+                    req->groups[i].tags[k].value.val_array_double.length);
+                memcpy(
+                    cmd->groups[i].tags[k].value.value.f64s.f64s,
+                    req->groups[i].tags[k].value.val_array_double.f64s,
+                    sizeof(double) *
+                        req->groups[i].tags[k].value.val_array_double.length);
+
                 break;
             case NEU_JSON_ARRAY_BOOL:
                 cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_BOOL;
                 cmd->groups[i].tags[k].value.value.bools.length =
                     req->groups[i].tags[k].value.val_array_bool.length;
-                for (int j = 0;
-                     j < req->groups[i].tags[k].value.val_array_bool.length;
+
+                cmd->groups[i].tags[k].value.value.bools.bools =
+                    calloc(sizeof(bool),
+                           req->groups[i].tags[k].value.val_array_bool.length);
+                memcpy(cmd->groups[i].tags[k].value.value.bools.bools,
+                       req->groups[i].tags[k].value.val_array_bool.bools,
+                       sizeof(bool) *
+                           req->groups[i].tags[k].value.val_array_bool.length);
+
+                break;
+            case NEU_JSON_ARRAY_STR:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_ARRAY_STRING;
+                cmd->groups[i].tags[k].value.value.strs.length =
+                    req->groups[i].tags[k].value.val_array_str.length;
+
+                cmd->groups[i].tags[k].value.value.strs.strs =
+                    calloc(sizeof(char *),
+                           req->groups[i].tags[k].value.val_array_str.length);
+                for (size_t j = 0;
+                     j < req->groups[i].tags[k].value.val_array_str.length;
                      j++) {
-                    cmd->groups[i].tags[k].value.value.bools.bools[j] =
-                        req->groups[i].tags[k].value.val_array_bool.bools[j];
+                    cmd->groups[i].tags[k].value.value.strs.strs[j] = strdup(
+                        req->groups[i].tags[k].value.val_array_str.p_strs[j]);
                 }
+
+                break;
+            case NEU_JSON_OBJECT:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_CUSTOM;
+                cmd->groups[i].tags[k].value.value.json =
+                    req->groups[i].tags[k].value.val_object;
                 break;
             default:
                 assert(false);
@@ -738,39 +778,42 @@ void handle_write_gtags(nng_aio *aio)
                     neu_otel_split_traceparent(trace_parent, trace_id, span_id,
                                                &flags);
                     if (strlen(trace_id) == 32) {
-                        trace_flag = true;
-                        trace      = neu_otel_create_trace(trace_id, header.ctx,
+                        trace = neu_otel_create_trace(trace_id, header.ctx,
                                                       flags, trace_state);
-                        scope      = neu_otel_add_span(trace);
-                        neu_otel_scope_set_span_name(
-                            scope, nng_http_req_get_uri(nng_req));
-                        char new_span_id[36] = { 0 };
-                        neu_otel_new_span_id(new_span_id);
-                        neu_otel_scope_set_span_id(scope, new_span_id);
-                        if (strlen(span_id) == 16) {
-                            neu_otel_scope_set_parent_span_id(scope, span_id);
-                        }
-                        neu_otel_scope_set_span_flags(scope, flags);
-                        neu_otel_scope_set_span_start_time(scope,
-                                                           neu_time_ns());
+                        if (trace) {
+                            trace_flag = true;
+                            scope      = neu_otel_add_span(trace);
+                            neu_otel_scope_set_span_name(
+                                scope, nng_http_req_get_uri(nng_req));
+                            char new_span_id[36] = { 0 };
+                            neu_otel_new_span_id(new_span_id);
+                            neu_otel_scope_set_span_id(scope, new_span_id);
+                            if (strlen(span_id) == 16) {
+                                neu_otel_scope_set_parent_span_id(scope,
+                                                                  span_id);
+                            }
+                            neu_otel_scope_set_span_flags(scope, flags);
+                            neu_otel_scope_set_span_start_time(scope,
+                                                               neu_time_ns());
 
-                        neu_otel_scope_add_span_attr_int(
-                            scope, "thread id", (int64_t) pthread_self());
+                            neu_otel_scope_add_span_attr_int(
+                                scope, "thread id", (int64_t) pthread_self());
 
-                        neu_otel_scope_add_span_attr_string(
-                            scope, "HTTP method",
-                            nng_http_req_get_method(nng_req));
-
-                        char * req_data      = NULL;
-                        size_t req_data_size = 0;
-
-                        if (neu_http_get_body((aio), (void **) &req_data,
-                                              &req_data_size) == 0) {
                             neu_otel_scope_add_span_attr_string(
-                                scope, "HTTP body", req_data);
-                        }
+                                scope, "HTTP method",
+                                nng_http_req_get_method(nng_req));
 
-                        free(req_data);
+                            char * req_data      = NULL;
+                            size_t req_data_size = 0;
+
+                            if (neu_http_get_body((aio), (void **) &req_data,
+                                                  &req_data_size) == 0) {
+                                neu_otel_scope_add_span_attr_string(
+                                    scope, "HTTP body", req_data);
+                            }
+
+                            free(req_data);
+                        }
                     }
                 }
             }
@@ -826,6 +869,7 @@ void handle_read_resp(nng_aio *aio, neu_resp_read_group_t *resp)
                  j++) {
                 free(api_res.tags[i].value.val_array_str.p_strs[j]);
             }
+            free(api_res.tags[i].value.val_array_str.p_strs);
         }
     }
     neu_http_ok(aio, result);
@@ -973,6 +1017,7 @@ void handle_read_paginate_resp(nng_aio *                       aio,
                  j++) {
                 free(api_res.tags[i].value.val_array_str.p_strs[j]);
             }
+            free(api_res.tags[i].value.val_array_str.p_strs);
         }
     }
     neu_http_ok(aio, result);

src/adapter/adapter.c

@@ -121,8 +121,19 @@ static void *adapter_consumer(void *arg)
         nlog_debug("adapter(%s) recv msg from: %s %p, type: %s, %u",
                    adapter->name, header->sender, header->ctx,
                    neu_reqresp_type_string(header->type), n);
-        adapter->module->intf_funs->request(
-            adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
+        if (adapter->state == NEU_NODE_RUNNING_STATE_RUNNING) {
+            adapter->module->intf_funs->request(
+                adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
+        } else {
+            void *ctx = ((neu_reqresp_trans_data_t *) &header[1])->trace_ctx;
+            if (neu_otel_data_is_started() && ctx) {
+                neu_otel_trace_ctx trace = neu_otel_find_trace(ctx);
+                if (trace) {
+                    neu_otel_trace_reduce_expected_span_num(trace, 1);
+                }
+            }
+        }
+
         neu_trans_data_free((neu_reqresp_trans_data_t *) &header[1]);
         neu_msg_free(msg);
     }
@@ -1022,12 +1033,15 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         break;
     }
     case NEU_REQ_GET_GROUP: {
+
+        neu_req_get_group_t *cmd = (neu_req_get_group_t *) &header[1];
+
         neu_msg_exchange(header);
 
         if (adapter->module->type == NEU_NA_TYPE_DRIVER) {
             neu_resp_get_group_t resp = {
                 .groups = neu_adapter_driver_get_group(
-                    (neu_adapter_driver_t *) adapter)
+                    (neu_adapter_driver_t *) adapter, cmd->q_group)
             };
             header->type = NEU_RESP_GET_GROUP;
             reply(adapter, header, &resp);
@@ -1725,6 +1739,16 @@ neu_node_state_t neu_adapter_get_state(neu_adapter_t *adapter)
     return state;
 }
 
+UT_array *neu_adapter_get_groups(neu_adapter_t *adapter, const char *filter)
+{
+    if (adapter->module->type != NEU_NA_TYPE_DRIVER) {
+        return NULL;
+    } else {
+        return neu_adapter_driver_get_group((neu_adapter_driver_t *) adapter,
+                                            filter);
+    }
+}
+
 neu_event_timer_t *neu_adapter_add_timer(neu_adapter_t *         adapter,
                                          neu_event_timer_param_t param)
 {

src/adapter/adapter_internal.h

@@ -95,6 +95,7 @@ void neu_adapter_del_timer(neu_adapter_t *adapter, neu_event_timer_t *timer);
 int neu_adapter_set_setting(neu_adapter_t *adapter, const char *config);
 int neu_adapter_get_setting(neu_adapter_t *adapter, char **config);
 neu_node_state_t neu_adapter_get_state(neu_adapter_t *adapter);
+UT_array *neu_adapter_get_groups(neu_adapter_t *adapter, const char *filter);
 
 static inline void neu_adapter_reset_metrics(neu_adapter_t *adapter)
 {

src/adapter/driver/cache.c

@@ -45,7 +45,8 @@ struct elem {
     neu_dvalue_t value;
     neu_dvalue_t value_old;
 
-    neu_tag_meta_t metas[NEU_TAG_META_SIZE];
+    neu_tag_meta_t *metas;
+    int             n_meta;
 
     tkey_t         key;
     UT_hash_handle hh;
@@ -105,10 +106,21 @@ void neu_driver_cache_destroy(neu_driver_cache_t *cache)
                 elem->value.value.json = NULL;
             }
         } else if (elem->value.type == NEU_TYPE_ARRAY_STRING) {
-            for (int i = 0; i < elem->value.value.strs.length; i++) {
+            for (size_t i = 0; i < elem->value.value.strs.length; i++) {
                 free(elem->value.value.strs.strs[i]);
                 elem->value.value.strs.strs[i] = NULL;
             }
+            free(elem->value.value.strs.strs);
+        } else if (NEU_TYPE_ARRAY_CHAR < elem->value.type &&
+                   elem->value.type < NEU_TYPE_ARRAY_STRING) {
+            free(elem->value.value.bools.bools);
+        }
+
+        if (elem->metas != NULL) {
+            for (int i = 0; i < elem->n_meta; i++) {
+                neu_free_dvalue(&elem->metas[i].value);
+            }
+            free(elem->metas);
         }
 
         free(elem);
@@ -708,16 +720,23 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
 
         } else if (value.type == NEU_TYPE_ARRAY_STRING) {
             if (elem->value.type == NEU_TYPE_ARRAY_STRING) {
-                for (int i = 0; i < elem->value.value.strs.length; i++) {
+                for (size_t i = 0; i < elem->value.value.strs.length; i++) {
                     free(elem->value.value.strs.strs[i]);
                     elem->value.value.strs.strs[i] = NULL;
                 }
+                free(elem->value.value.strs.strs);
             }
             elem->value.value.strs.length = value.value.strs.length;
-            for (int i = 0; i < value.value.strs.length; i++) {
-                elem->value.value.strs.strs[i] = value.value.strs.strs[i];
-            }
+            elem->value.value.strs.strs   = value.value.strs.strs;
 
+        } else if (NEU_TYPE_ARRAY_CHAR < value.type &&
+                   value.type < NEU_TYPE_ARRAY_STRING) {
+            if (NEU_TYPE_ARRAY_CHAR < elem->value.type &&
+                elem->value.type < NEU_TYPE_ARRAY_STRING) {
+                free(elem->value.value.bools.bools);
+            }
+            elem->value.value.bools.length = value.value.bools.length;
+            elem->value.value.bools.bools  = value.value.bools.bools;
         } else if (value.type == NEU_TYPE_ERROR) {
             if (elem->value.type == NEU_TYPE_CUSTOM) {
                 if (elem->value.value.json != NULL) {
@@ -726,21 +745,43 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
                 }
             }
 
+            if (elem->value.type == NEU_TYPE_PTR) {
+                if (elem->value.value.ptr.ptr != NULL) {
+                    free(elem->value.value.ptr.ptr);
+                    elem->value.value.ptr.ptr = NULL;
+                }
+            }
+
             if (elem->value.type == NEU_TYPE_ARRAY_STRING) {
-                for (int i = 0; i < elem->value.value.strs.length; i++) {
+                for (size_t i = 0; i < elem->value.value.strs.length; i++) {
                     free(elem->value.value.strs.strs[i]);
                     elem->value.value.strs.strs[i] = NULL;
                 }
+                free(elem->value.value.strs.strs);
             }
+
+            if (NEU_TYPE_ARRAY_CHAR < elem->value.type &&
+                elem->value.type < NEU_TYPE_ARRAY_STRING) {
+                free(elem->value.value.bools.bools);
+                elem->value.value.bools.bools = NULL;
+            }
+
             elem->value.value = value.value;
         } else {
             elem->value.value = value.value;
         }
         elem->value.type = value.type;
 
-        memset(elem->metas, 0, sizeof(neu_tag_meta_t) * NEU_TAG_META_SIZE);
-        for (int i = 0; i < n_meta; i++) {
-            memcpy(&elem->metas[i], &metas[i], sizeof(neu_tag_meta_t));
+        if (metas != NULL) {
+            if (elem->metas != NULL) {
+                free(elem->metas);
+            }
+            elem->metas = calloc(n_meta, sizeof(neu_tag_meta_t));
+            for (int i = 0; i < n_meta; i++) {
+                memcpy(&elem->metas[i], &metas[i], sizeof(neu_tag_meta_t));
+            }
+
+            elem->n_meta = n_meta;
         }
     }
 
@@ -758,7 +799,7 @@ void neu_driver_cache_update(neu_driver_cache_t *cache, const char *group,
 
 int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
                               const char *tag, neu_driver_cache_value_t *value,
-                              neu_tag_meta_t *metas, int n_meta)
+                              neu_tag_meta_t **metas, int *n_meta)
 {
     struct elem *elem = NULL;
     int          ret  = -1;
@@ -772,8 +813,14 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
         value->value.type      = elem->value.type;
         value->value.precision = elem->value.precision;
 
-        assert(n_meta <= NEU_TAG_META_SIZE);
-        memcpy(metas, elem->metas, sizeof(neu_tag_meta_t) * NEU_TAG_META_SIZE);
+        // assert(n_meta <= NEU_TAG_META_SIZE);
+        if (elem->metas) {
+            *metas = calloc(elem->n_meta, sizeof(neu_tag_meta_t));
+            memcpy(*metas, elem->metas, sizeof(neu_tag_meta_t) * elem->n_meta);
+        } else {
+            *metas = NULL;
+        }
+        *n_meta = elem->n_meta;
 
         switch (elem->value.type) {
         case NEU_TYPE_INT8:
@@ -817,63 +864,87 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
             break;
         case NEU_TYPE_ARRAY_BOOL:
             value->value.value.bools.length = elem->value.value.bools.length;
+            value->value.value.bools.bools =
+                calloc(elem->value.value.bools.length, sizeof(bool));
             memcpy(value->value.value.bools.bools,
                    elem->value.value.bools.bools,
                    elem->value.value.bools.length);
             break;
         case NEU_TYPE_ARRAY_INT8:
             value->value.value.i8s.length = elem->value.value.i8s.length;
+            value->value.value.i8s.i8s =
+                calloc(elem->value.value.i8s.length, sizeof(int8_t));
             memcpy(value->value.value.i8s.i8s, elem->value.value.i8s.i8s,
                    elem->value.value.i8s.length);
             break;
         case NEU_TYPE_ARRAY_UINT8:
             value->value.value.u8s.length = elem->value.value.u8s.length;
+            value->value.value.u8s.u8s =
+                calloc(elem->value.value.u8s.length, sizeof(uint8_t));
             memcpy(value->value.value.u8s.u8s, elem->value.value.u8s.u8s,
                    elem->value.value.u8s.length);
             break;
         case NEU_TYPE_ARRAY_INT16:
             value->value.value.i16s.length = elem->value.value.i16s.length;
+            value->value.value.i16s.i16s =
+                calloc(elem->value.value.i16s.length, sizeof(int16_t));
             memcpy(value->value.value.i16s.i16s, elem->value.value.i16s.i16s,
                    elem->value.value.i16s.length * sizeof(int16_t));
             break;
         case NEU_TYPE_ARRAY_UINT16:
             value->value.value.u16s.length = elem->value.value.u16s.length;
+            value->value.value.u16s.u16s =
+                calloc(elem->value.value.u16s.length, sizeof(uint16_t));
             memcpy(value->value.value.u16s.u16s, elem->value.value.u16s.u16s,
                    elem->value.value.u16s.length * sizeof(uint16_t));
             break;
         case NEU_TYPE_ARRAY_INT32:
             value->value.value.i32s.length = elem->value.value.i32s.length;
+            value->value.value.i32s.i32s =
+                calloc(elem->value.value.i32s.length, sizeof(int32_t));
             memcpy(value->value.value.i32s.i32s, elem->value.value.i32s.i32s,
                    elem->value.value.i32s.length * sizeof(int32_t));
             break;
         case NEU_TYPE_ARRAY_UINT32:
             value->value.value.u32s.length = elem->value.value.u32s.length;
+            value->value.value.u32s.u32s =
+                calloc(elem->value.value.u32s.length, sizeof(uint32_t));
             memcpy(value->value.value.u32s.u32s, elem->value.value.u32s.u32s,
                    elem->value.value.u32s.length * sizeof(uint32_t));
             break;
         case NEU_TYPE_ARRAY_INT64:
             value->value.value.i64s.length = elem->value.value.i64s.length;
+            value->value.value.i64s.i64s =
+                calloc(elem->value.value.i64s.length, sizeof(int64_t));
             memcpy(value->value.value.i64s.i64s, elem->value.value.i64s.i64s,
                    elem->value.value.i64s.length * sizeof(int64_t));
             break;
         case NEU_TYPE_ARRAY_UINT64:
             value->value.value.u64s.length = elem->value.value.u64s.length;
+            value->value.value.u64s.u64s =
+                calloc(elem->value.value.u64s.length, sizeof(uint64_t));
             memcpy(value->value.value.u64s.u64s, elem->value.value.u64s.u64s,
                    elem->value.value.u64s.length * sizeof(uint64_t));
             break;
         case NEU_TYPE_ARRAY_FLOAT:
             value->value.value.f32s.length = elem->value.value.f32s.length;
+            value->value.value.f32s.f32s =
+                calloc(elem->value.value.f32s.length, sizeof(float));
             memcpy(value->value.value.f32s.f32s, elem->value.value.f32s.f32s,
                    elem->value.value.f32s.length * sizeof(float));
             break;
         case NEU_TYPE_ARRAY_DOUBLE:
             value->value.value.f64s.length = elem->value.value.f64s.length;
+            value->value.value.f64s.f64s =
+                calloc(elem->value.value.f64s.length, sizeof(double));
             memcpy(value->value.value.f64s.f64s, elem->value.value.f64s.f64s,
                    elem->value.value.f64s.length * sizeof(double));
             break;
         case NEU_TYPE_ARRAY_STRING:
             value->value.value.strs.length = elem->value.value.strs.length;
-            for (int i = 0; i < elem->value.value.strs.length; i++) {
+            value->value.value.strs.strs =
+                calloc(elem->value.value.strs.length, sizeof(char *));
+            for (size_t i = 0; i < elem->value.value.strs.length; i++) {
                 value->value.value.strs.strs[i] =
                     strdup(elem->value.value.strs.strs[i]);
             }
@@ -891,13 +962,6 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
             break;
         }
 
-        for (int i = 0; i < NEU_TAG_META_SIZE; i++) {
-            if (strlen(elem->metas[i].name) > 0) {
-                memcpy(&value->metas[i], &elem->metas[i],
-                       sizeof(neu_tag_meta_t));
-            }
-        }
-
         ret = 0;
     }
 
@@ -909,7 +973,7 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
 int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
                                       const char *group, const char *tag,
                                       neu_driver_cache_value_t *value,
-                                      neu_tag_meta_t *metas, int n_meta)
+                                      neu_tag_meta_t **metas, int *n_meta)
 {
     struct elem *elem = NULL;
     int          ret  = -1;
@@ -923,8 +987,14 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
         value->value.type      = elem->value.type;
         value->value.precision = elem->value.precision;
 
-        assert(n_meta <= NEU_TAG_META_SIZE);
-        memcpy(metas, elem->metas, sizeof(neu_tag_meta_t) * NEU_TAG_META_SIZE);
+        // assert(n_meta <= NEU_TAG_META_SIZE);
+        if (elem->metas) {
+            *metas = calloc(elem->n_meta, sizeof(neu_tag_meta_t));
+            memcpy(*metas, elem->metas, sizeof(neu_tag_meta_t) * elem->n_meta);
+        } else {
+            *metas = NULL;
+        }
+        *n_meta = elem->n_meta;
 
         switch (elem->value.type) {
         case NEU_TYPE_INT8:
@@ -968,63 +1038,87 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
             break;
         case NEU_TYPE_ARRAY_BOOL:
             value->value.value.bools.length = elem->value.value.bools.length;
+            value->value.value.bools.bools =
+                calloc(elem->value.value.bools.length, sizeof(bool));
             memcpy(value->value.value.bools.bools,
                    elem->value.value.bools.bools,
                    elem->value.value.bools.length);
             break;
         case NEU_TYPE_ARRAY_INT8:
             value->value.value.i8s.length = elem->value.value.i8s.length;
+            value->value.value.i8s.i8s =
+                calloc(elem->value.value.i8s.length, sizeof(int8_t));
             memcpy(value->value.value.i8s.i8s, elem->value.value.i8s.i8s,
                    elem->value.value.i8s.length);
             break;
         case NEU_TYPE_ARRAY_UINT8:
             value->value.value.u8s.length = elem->value.value.u8s.length;
+            value->value.value.u8s.u8s =
+                calloc(elem->value.value.u8s.length, sizeof(uint8_t));
             memcpy(value->value.value.u8s.u8s, elem->value.value.u8s.u8s,
                    elem->value.value.u8s.length);
             break;
         case NEU_TYPE_ARRAY_INT16:
             value->value.value.i16s.length = elem->value.value.i16s.length;
+            value->value.value.i16s.i16s =
+                calloc(elem->value.value.i16s.length, sizeof(int16_t));
             memcpy(value->value.value.i16s.i16s, elem->value.value.i16s.i16s,
                    elem->value.value.i16s.length * sizeof(int16_t));
             break;
         case NEU_TYPE_ARRAY_UINT16:
             value->value.value.u16s.length = elem->value.value.u16s.length;
+            value->value.value.u16s.u16s =
+                calloc(elem->value.value.u16s.length, sizeof(uint16_t));
             memcpy(value->value.value.u16s.u16s, elem->value.value.u16s.u16s,
                    elem->value.value.u16s.length * sizeof(uint16_t));
             break;
         case NEU_TYPE_ARRAY_INT32:
             value->value.value.i32s.length = elem->value.value.i32s.length;
+            value->value.value.i32s.i32s =
+                calloc(elem->value.value.i32s.length, sizeof(int32_t));
             memcpy(value->value.value.i32s.i32s, elem->value.value.i32s.i32s,
                    elem->value.value.i32s.length * sizeof(int32_t));
             break;
         case NEU_TYPE_ARRAY_UINT32:
             value->value.value.u32s.length = elem->value.value.u32s.length;
+            value->value.value.u32s.u32s =
+                calloc(elem->value.value.u32s.length, sizeof(uint32_t));
             memcpy(value->value.value.u32s.u32s, elem->value.value.u32s.u32s,
                    elem->value.value.u32s.length * sizeof(uint32_t));
             break;
         case NEU_TYPE_ARRAY_INT64:
             value->value.value.i64s.length = elem->value.value.i64s.length;
+            value->value.value.i64s.i64s =
+                calloc(elem->value.value.i64s.length, sizeof(int64_t));
             memcpy(value->value.value.i64s.i64s, elem->value.value.i64s.i64s,
                    elem->value.value.i64s.length * sizeof(int64_t));
             break;
         case NEU_TYPE_ARRAY_UINT64:
             value->value.value.u64s.length = elem->value.value.u64s.length;
+            value->value.value.u64s.u64s =
+                calloc(elem->value.value.u64s.length, sizeof(uint64_t));
             memcpy(value->value.value.u64s.u64s, elem->value.value.u64s.u64s,
                    elem->value.value.u64s.length * sizeof(uint64_t));
             break;
         case NEU_TYPE_ARRAY_FLOAT:
             value->value.value.f32s.length = elem->value.value.f32s.length;
+            value->value.value.f32s.f32s =
+                calloc(elem->value.value.f32s.length, sizeof(float));
             memcpy(value->value.value.f32s.f32s, elem->value.value.f32s.f32s,
                    elem->value.value.f32s.length * sizeof(float));
             break;
         case NEU_TYPE_ARRAY_DOUBLE:
             value->value.value.f64s.length = elem->value.value.f64s.length;
+            value->value.value.f64s.f64s =
+                calloc(elem->value.value.f64s.length, sizeof(double));
             memcpy(value->value.value.f64s.f64s, elem->value.value.f64s.f64s,
                    elem->value.value.f64s.length * sizeof(double));
             break;
         case NEU_TYPE_ARRAY_STRING:
             value->value.value.strs.length = elem->value.value.strs.length;
-            for (int i = 0; i < elem->value.value.strs.length; i++) {
+            value->value.value.strs.strs =
+                calloc(elem->value.value.strs.length, sizeof(char *));
+            for (size_t i = 0; i < elem->value.value.strs.length; i++) {
                 value->value.value.strs.strs[i] =
                     strdup(elem->value.value.strs.strs[i]);
             }
@@ -1042,13 +1136,6 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
             break;
         }
 
-        for (int i = 0; i < NEU_TAG_META_SIZE; i++) {
-            if (strlen(elem->metas[i].name) > 0) {
-                memcpy(&value->metas[i], &elem->metas[i],
-                       sizeof(neu_tag_meta_t));
-            }
-        }
-
         if (elem->value.type != NEU_TYPE_ERROR) {
             elem->changed = false;
         }
@@ -1082,10 +1169,20 @@ void neu_driver_cache_del(neu_driver_cache_t *cache, const char *group,
                 elem->value.value.json = NULL;
             }
         } else if (elem->value.type == NEU_TYPE_ARRAY_STRING) {
-            for (int i = 0; i < elem->value.value.strs.length; i++) {
+            for (size_t i = 0; i < elem->value.value.strs.length; i++) {
                 free(elem->value.value.strs.strs[i]);
                 elem->value.value.strs.strs[i] = NULL;
             }
+            free(elem->value.value.strs.strs);
+        } else if (NEU_TYPE_ARRAY_CHAR < elem->value.type &&
+                   elem->value.type < NEU_TYPE_ARRAY_STRING) {
+            free(elem->value.value.bools.bools);
+        }
+        if (elem->metas != NULL) {
+            for (int i = 0; i < elem->n_meta; i++) {
+                neu_free_dvalue(&elem->metas[i].value);
+            }
+            free(elem->metas);
         }
         free(elem);
     }

src/adapter/driver/cache.h

@@ -50,17 +50,16 @@ void neu_driver_cache_update_trace(neu_driver_cache_t *cache, const char *group,
 void *neu_driver_cache_get_trace(neu_driver_cache_t *cache, const char *group);
 
 typedef struct {
-    neu_dvalue_t   value;
-    int64_t        timestamp;
-    neu_tag_meta_t metas[NEU_TAG_META_SIZE];
+    neu_dvalue_t value;
+    int64_t      timestamp;
 } neu_driver_cache_value_t;
 
 int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
                               const char *tag, neu_driver_cache_value_t *value,
-                              neu_tag_meta_t *metas, int n_meta);
+                              neu_tag_meta_t **metas, int *n_meta);
 int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
                                       const char *group, const char *tag,
                                       neu_driver_cache_value_t *value,
-                                      neu_tag_meta_t *metas, int n_meta);
+                                      neu_tag_meta_t **metas, int *n_meta);
 
 #endif

src/adapter/driver/driver.c

@@ -40,6 +40,7 @@
 #include "errcodes.h"
 #include "tag.h"
 
+#include "core/node_manager.h"
 #include "otel/otel_manager.h"
 
 typedef struct to_be_write_tag {
@@ -356,6 +357,8 @@ static void update_im(neu_adapter_t *adapter, const char *group,
                 {
                     if (tag_value->value.type == NEU_TYPE_PTR) {
                         free(tag_value->value.value.ptr.ptr);
+                    } else {
+                        neu_free_dvalue(&tag_value->value);
                     }
                 }
                 utarray_free(data->tags);
@@ -369,6 +372,8 @@ static void update_im(neu_adapter_t *adapter, const char *group,
             {
                 if (tag_value->value.type == NEU_TYPE_PTR) {
                     free(tag_value->value.value.ptr.ptr);
+                } else {
+                    neu_free_dvalue(&tag_value->value);
                 }
             }
             utarray_free(data->tags);
@@ -826,137 +831,133 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
     case NEU_TYPE_LWORD:
         switch (tag->option.value64.endian) {
         case NEU_DATATAG_ENDIAN_B64:
+        case NEU_DATATAG_ENDIAN_BB64:
             value->value.u64 = neu_ntohll(value->value.u64);
             break;
+        case NEU_DATATAG_ENDIAN_LB64:
+            value->value.u64 = neu_htonlb(value->value.u64);
+            break;
+        case NEU_DATATAG_ENDIAN_BL64:
+            value->value.u64 = neu_htonbl(value->value.u64);
+            break;
         case NEU_DATATAG_ENDIAN_L64:
+        case NEU_DATATAG_ENDIAN_LL64:
         default:
             break;
         }
         break;
     case NEU_TYPE_BYTES:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.bytes.bytes[i] =
-                    (uint8_t) value->value.i64s.i64s[i];
+            int64_t *i64s     = value->value.i64s.i64s;
+            uint32_t i64s_len = value->value.i64s.length > NEU_VALUE_SIZE
+                ? NEU_VALUE_SIZE
+                : value->value.i64s.length;
+            for (size_t i = 0; i < i64s_len; i++) {
+                value->value.bytes.bytes[i] = (uint8_t) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
+            for (int i = i64s_len; i < NEU_VALUE_SIZE; i++) {
                 value->value.bytes.bytes[i] = 0;
             }
-            value->value.bytes.length = value->value.i64s.length;
+            value->value.bytes.length = i64s_len;
+            free(i64s);
         }
         break;
     case NEU_TYPE_ARRAY_INT8:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.i8s.i8s[i] = (int8_t) value->value.i64s.i64s[i];
+            int64_t *i64s        = value->value.i64s.i64s;
+            value->value.i8s.i8s = calloc(value->value.i64s.length, 1);
+            for (size_t i = 0; i < value->value.i64s.length; i++) {
+                value->value.i8s.i8s[i] = (int8_t) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.i8s.i8s[i] = 0;
-            }
-            value->value.i8s.length = value->value.i64s.length;
+            free(i64s);
         }
         break;
     case NEU_TYPE_ARRAY_UINT8:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.u8s.u8s[i] = (uint8_t) value->value.i64s.i64s[i];
+            int64_t *i64s        = value->value.i64s.i64s;
+            value->value.u8s.u8s = calloc(value->value.i64s.length, 1);
+            for (size_t i = 0; i < value->value.i64s.length; i++) {
+                value->value.u8s.u8s[i] = (uint8_t) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.u8s.u8s[i] = 0;
-            }
-            value->value.u8s.length = value->value.i64s.length;
+            free(i64s);
         }
         break;
     case NEU_TYPE_ARRAY_INT16:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.i16s.i16s[i] = (int16_t) value->value.i64s.i64s[i];
+            int64_t *i64s          = value->value.i64s.i64s;
+            value->value.i16s.i16s = calloc(value->value.i64s.length, 2);
+            for (size_t i = 0; i < value->value.i64s.length; i++) {
+                value->value.i16s.i16s[i] = (int16_t) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.i16s.i16s[i] = 0;
-            }
-            value->value.i16s.length = value->value.i64s.length;
+            free(i64s);
         }
         break;
     case NEU_TYPE_ARRAY_UINT16:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.u16s.u16s[i] =
-                    (uint16_t) value->value.i64s.i64s[i];
+            int64_t *i64s          = value->value.i64s.i64s;
+            value->value.u16s.u16s = calloc(value->value.i64s.length, 2);
+            for (size_t i = 0; i < value->value.i64s.length; i++) {
+                value->value.u16s.u16s[i] = (uint16_t) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.u16s.u16s[i] = 0;
-            }
-            value->value.u16s.length = value->value.i64s.length;
+            free(i64s);
         }
         break;
     case NEU_TYPE_ARRAY_INT32:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.i32s.i32s[i] = (int32_t) value->value.i64s.i64s[i];
+            int64_t *i64s          = value->value.i64s.i64s;
+            value->value.i32s.i32s = calloc(value->value.i64s.length, 4);
+            for (size_t i = 0; i < value->value.i64s.length; i++) {
+                value->value.i32s.i32s[i] = (int32_t) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.i32s.i32s[i] = 0;
-            }
-            value->value.i32s.length = value->value.i64s.length;
+            free(i64s);
         }
         break;
     case NEU_TYPE_ARRAY_UINT32:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.u32s.u32s[i] =
-                    (uint32_t) value->value.i64s.i64s[i];
+            int64_t *i64s          = value->value.i64s.i64s;
+            value->value.u32s.u32s = calloc(value->value.i64s.length, 4);
+            for (size_t i = 0; i < value->value.i64s.length; i++) {
+                value->value.u32s.u32s[i] = (uint32_t) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.u32s.u32s[i] = 0;
-            }
-            value->value.u32s.length = value->value.i64s.length;
+            free(i64s);
         }
         break;
     case NEU_TYPE_ARRAY_UINT64:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.u64s.u64s[i] =
-                    (uint64_t) value->value.i64s.i64s[i];
+            int64_t *i64s          = value->value.i64s.i64s;
+            value->value.u64s.u64s = calloc(value->value.i64s.length, 8);
+            for (size_t i = 0; i < value->value.i64s.length; i++) {
+                value->value.u64s.u64s[i] = (uint64_t) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.u64s.u64s[i] = 0;
-            }
-            value->value.u64s.length = value->value.i64s.length;
+            free(i64s);
         }
         break;
     case NEU_TYPE_ARRAY_FLOAT:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.f32s.f32s[i] = (float) value->value.i64s.i64s[i];
+            int64_t *i64s          = value->value.i64s.i64s;
+            value->value.f32s.f32s = calloc(value->value.i64s.length, 4);
+            for (size_t i = 0; i < value->value.i64s.length; i++) {
+                value->value.f32s.f32s[i] = (float) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.f32s.f32s[i] = 0;
-            }
-            value->value.f32s.length = value->value.i64s.length;
+            free(i64s);
         }
         if (value->type == NEU_TYPE_ARRAY_DOUBLE) {
-
-            for (int i = 0; i < value->value.f64s.length; i++) {
-                value->value.f32s.f32s[i] = (float) value->value.f64s.f64s[i];
+            double *f64s           = value->value.f64s.f64s;
+            value->value.f32s.f32s = calloc(value->value.f64s.length, 4);
+            for (size_t i = 0; i < value->value.f64s.length; i++) {
+                value->value.f32s.f32s[i] = (float) f64s[i];
             }
-            for (int i = value->value.f64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.f32s.f32s[i] = 0;
-            }
-            value->value.f32s.length = value->value.f64s.length;
+            free(f64s);
         }
         break;
     case NEU_TYPE_ARRAY_DOUBLE:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-
-            for (int i = 0; i < value->value.i64s.length; i++) {
-                value->value.f64s.f64s[i] = (double) value->value.i64s.i64s[i];
+            int64_t *i64s          = value->value.i64s.i64s;
+            value->value.f64s.f64s = calloc(value->value.i64s.length, 8);
+            for (size_t i = 0; i < value->value.i64s.length; i++) {
+                value->value.f64s.f64s[i] = (double) i64s[i];
             }
-            for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
-                value->value.f64s.f64s[i] = 0;
-            }
-            value->value.f64s.length = value->value.i64s.length;
+            free(i64s);
         }
         break;
     default:
@@ -1113,21 +1114,19 @@ int is_value_in_range(neu_type_e tag_type, int64_t value, double value_d,
                 return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
             }
         case NEU_TYPE_FLOAT:
-            if (write_type != NEU_TYPE_DOUBLE) {
+            if (write_type != NEU_TYPE_DOUBLE && write_type != NEU_TYPE_INT64) {
                 return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
-            } else if (result < (int64_t) -FLT_MAX ||
-                       result > (int64_t) FLT_MAX) {
+            }
+            if (result < (int64_t) -FLT_MAX || result > (int64_t) FLT_MAX) {
                 return NEU_ERR_PLUGIN_TAG_VALUE_OUT_OF_RANGE;
             } else {
                 return NEU_ERR_SUCCESS;
             }
         case NEU_TYPE_DOUBLE:
-            if (write_type != NEU_TYPE_DOUBLE) {
+            if (write_type != NEU_TYPE_DOUBLE && write_type != NEU_TYPE_INT64) {
                 return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
-            } else {
-                return NEU_ERR_SUCCESS;
             }
-            return check_value(write_type, result, INT16_MIN, INT16_MAX);
+            return NEU_ERR_SUCCESS;
         case NEU_TYPE_STRING:
         case NEU_TYPE_BOOL:
         case NEU_TYPE_BIT:
@@ -1171,20 +1170,19 @@ int is_value_in_range(neu_type_e tag_type, int64_t value, double value_d,
                 return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
             }
         case NEU_TYPE_FLOAT:
-            if (write_type != NEU_TYPE_DOUBLE) {
+            if (write_type != NEU_TYPE_DOUBLE && write_type != NEU_TYPE_INT64) {
                 return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
-            } else if (value < (int64_t) -FLT_MAX ||
-                       value > (int64_t) FLT_MAX) {
+            }
+            if (value < (int64_t) -FLT_MAX || value > (int64_t) FLT_MAX) {
                 return NEU_ERR_PLUGIN_TAG_VALUE_OUT_OF_RANGE;
             } else {
                 return NEU_ERR_SUCCESS;
             }
         case NEU_TYPE_DOUBLE:
-            if (write_type != NEU_TYPE_DOUBLE) {
+            if (write_type != NEU_TYPE_DOUBLE && write_type != NEU_TYPE_INT64) {
                 return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
-            } else {
-                return NEU_ERR_SUCCESS;
             }
+            return NEU_ERR_SUCCESS;
         case NEU_TYPE_STRING:
             if (write_type != NEU_TYPE_STRING) {
                 return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
@@ -1197,6 +1195,33 @@ int is_value_in_range(neu_type_e tag_type, int64_t value, double value_d,
             } else {
                 return NEU_ERR_SUCCESS;
             }
+        case NEU_TYPE_ARRAY_UINT8:
+        case NEU_TYPE_ARRAY_INT8:
+        case NEU_TYPE_ARRAY_UINT16:
+        case NEU_TYPE_ARRAY_INT16:
+        case NEU_TYPE_ARRAY_UINT32:
+        case NEU_TYPE_ARRAY_INT32:
+        case NEU_TYPE_ARRAY_UINT64:
+        case NEU_TYPE_ARRAY_INT64:
+            if (write_type != NEU_TYPE_ARRAY_INT64) {
+                return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
+            } else {
+                return NEU_ERR_SUCCESS;
+            }
+        case NEU_TYPE_ARRAY_FLOAT:
+        case NEU_TYPE_ARRAY_DOUBLE:
+            if (write_type != NEU_TYPE_ARRAY_DOUBLE &&
+                write_type != NEU_TYPE_ARRAY_INT64) {
+                return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
+            } else {
+                return NEU_ERR_SUCCESS;
+            }
+        case NEU_TYPE_ARRAY_STRING:
+            if (write_type != NEU_TYPE_ARRAY_STRING) {
+                return NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH;
+            } else {
+                return NEU_ERR_SUCCESS;
+            }
         default:
             return NEU_ERR_SUCCESS;
         }
@@ -1264,6 +1289,7 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
             neu_plugin_tag_value_t tv = {
                 .tag   = neu_tag_dup(tag),
                 .value = cmd->tags[i].value.value,
+                .type  = cmd->tags[i].value.type,
             };
             utarray_push_back(tags, &tv);
         } else {
@@ -1280,6 +1306,8 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
         utarray_foreach(tags, neu_plugin_tag_value_t *, tv)
         {
             neu_tag_free(tv->tag);
+            neu_dvalue_t dvalue = { .type = tv->type, .value = tv->value };
+            neu_free_dvalue(&dvalue);
         }
         utarray_free(tags);
         return value_err;
@@ -1291,6 +1319,8 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
         utarray_foreach(tags, neu_plugin_tag_value_t *, tv)
         {
             neu_tag_free(tv->tag);
+            neu_dvalue_t dvalue = { .type = tv->type, .value = tv->value };
+            neu_free_dvalue(&dvalue);
         }
         utarray_free(tags);
         return NEU_ERR_TAG_NOT_EXIST;
@@ -1727,7 +1757,8 @@ int neu_adapter_driver_group_exist(neu_adapter_driver_t *driver,
     return ret;
 }
 
-UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver)
+UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver,
+                                       const char *          filter)
 {
     group_t * el = NULL, *tmp = NULL;
     UT_array *groups = NULL;
@@ -1737,13 +1768,16 @@ UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver)
 
     HASH_ITER(hh, driver->groups, el, tmp)
     {
-        neu_resp_group_info_t info = { 0 };
 
-        info.interval  = neu_group_get_interval(el->group);
-        info.tag_count = neu_group_tag_size(el->group);
-        strncpy(info.name, el->name, sizeof(info.name));
+        if (strlen(filter) == 0 || strstr(el->name, filter) != NULL) {
+            neu_resp_group_info_t info = { 0 };
 
-        utarray_push_back(groups, &info);
+            info.interval  = neu_group_get_interval(el->group);
+            info.tag_count = neu_group_tag_size(el->group);
+            strncpy(info.name, el->name, sizeof(info.name));
+
+            utarray_push_back(groups, &info);
+        }
     }
 
     return groups;
@@ -2096,25 +2130,24 @@ static int report_callback(void *usr_data)
     data->driver = strdup(group->driver->adapter.name);
     data->group  = strdup(group->name);
     utarray_new(data->tags, neu_resp_tag_value_meta_icd());
+    utarray_reserve(data->tags, utarray_len(tags));
 
     void *trace_ctx =
         neu_driver_cache_get_trace(group->driver->cache, group->name);
 
     neu_otel_trace_ctx trans_trace = NULL;
     neu_otel_scope_ctx trans_scope = NULL;
-    if (trace_ctx) {
-        data->trace_ctx = trace_ctx;
-        if (neu_otel_data_is_started() && data->trace_ctx) {
-            trans_trace = neu_otel_find_trace(data->trace_ctx);
-            if (trans_trace) {
-                char new_span_id[36] = { 0 };
-                neu_otel_new_span_id(new_span_id);
-                trans_scope =
-                    neu_otel_add_span2(trans_trace, "report cb", new_span_id);
-                neu_otel_scope_add_span_attr_int(trans_scope, "thread id",
-                                                 (int64_t)(pthread_self()));
-                neu_otel_scope_set_span_start_time(trans_scope, neu_time_ns());
-            }
+    if (neu_otel_data_is_started() && trace_ctx) {
+        trans_trace = neu_otel_find_trace2(trace_ctx);
+        if (trans_trace) {
+            data->trace_ctx      = trace_ctx;
+            char new_span_id[36] = { 0 };
+            neu_otel_new_span_id(new_span_id);
+            trans_scope =
+                neu_otel_add_span2(trans_trace, "report cb", new_span_id);
+            neu_otel_scope_add_span_attr_int(trans_scope, "thread id",
+                                             (int64_t)(pthread_self()));
+            neu_otel_scope_set_span_start_time(trans_scope, neu_time_ns());
         }
     }
 
@@ -2143,9 +2176,12 @@ static int report_callback(void *usr_data)
                 }
             }
 
+            if (trans_trace) {
+                neu_otel_set_internal_parent_span(trans_trace);
+            }
+
             utarray_foreach(group->apps, sub_app_t *, app)
             {
-
                 if (group->driver->adapter.cb_funs.responseto(
                         &group->driver->adapter, &header, data, app->addr) !=
                     0) {
@@ -2183,13 +2219,15 @@ static int report_callback(void *usr_data)
             {
                 if (tag_value->value.type == NEU_TYPE_PTR) {
                     free(tag_value->value.value.ptr.ptr);
-                } else if (tag_value->value.type == NEU_TYPE_CUSTOM) {
-                    json_decref(tag_value->value.value.json);
-                } else if (tag_value->value.type == NEU_TYPE_ARRAY_STRING) {
-                    for (size_t i = 0; i < tag_value->value.value.strs.length;
-                         ++i) {
-                        free(tag_value->value.value.strs.strs[i]);
+                } else {
+                    neu_free_dvalue(&tag_value->value);
+                }
+
+                if (tag_value->metas != NULL) {
+                    for (int i = 0; i < tag_value->n_meta; i++) {
+                        neu_free_dvalue(&tag_value->metas[i].value);
                     }
+                    free(tag_value->metas);
                 }
             }
             utarray_free(data->tags);
@@ -2395,15 +2433,15 @@ static void read_report_group(int64_t timestamp, int64_t timeout,
 
         if (neu_tag_attribute_test(tag, NEU_ATTRIBUTE_SUBSCRIBE)) {
             if (neu_driver_cache_meta_get_changed(cache, group, tag->name,
-                                                  &value, tag_value.metas,
-                                                  NEU_TAG_META_SIZE) != 0) {
+                                                  &value, &tag_value.metas,
+                                                  &tag_value.n_meta) != 0) {
                 nlog_debug("tag: %s not changed", tag->name);
                 continue;
             }
         } else {
             if (neu_driver_cache_meta_get(cache, group, tag->name, &value,
-                                          tag_value.metas,
-                                          NEU_TAG_META_SIZE) != 0) {
+                                          &tag_value.metas,
+                                          &tag_value.n_meta) != 0) {
                 strcpy(tag_value.tag, tag->name);
                 tag_value.value.type      = NEU_TYPE_ERROR;
                 tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
@@ -2476,9 +2514,17 @@ static void read_report_group(int64_t timestamp, int64_t timeout,
         case NEU_TYPE_UINT64:
             switch (tag->option.value64.endian) {
             case NEU_DATATAG_ENDIAN_B64:
+            case NEU_DATATAG_ENDIAN_BB64:
                 value.value.value.u64 = neu_htonll(value.value.value.u64);
                 break;
+            case NEU_DATATAG_ENDIAN_LB64:
+                value.value.value.u64 = neu_htonlb(value.value.value.u64);
+                break;
+            case NEU_DATATAG_ENDIAN_BL64:
+                value.value.value.u64 = neu_htonbl(value.value.value.u64);
+                break;
             case NEU_DATATAG_ENDIAN_L64:
+            case NEU_DATATAG_ENDIAN_LL64:
             default:
                 break;
             }
@@ -2491,12 +2537,8 @@ static void read_report_group(int64_t timestamp, int64_t timeout,
             (timestamp - value.timestamp) > timeout && timeout > 0) {
             if (value.value.type == NEU_TYPE_PTR) {
                 free(value.value.value.ptr.ptr);
-            } else if (value.value.type == NEU_TYPE_CUSTOM) {
-                json_decref(value.value.value.json);
-            } else if (value.value.type == NEU_TYPE_ARRAY_STRING) {
-                for (size_t i = 0; i < value.value.value.strs.length; ++i) {
-                    free(value.value.value.strs.strs[i]);
-                }
+            } else {
+                neu_free_dvalue(&value.value);
             }
             tag_value.value.type      = NEU_TYPE_ERROR;
             tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED;
@@ -2586,8 +2628,8 @@ static void read_group(int64_t timestamp, int64_t timeout,
         tag_value.datatag.bias = tag->bias;
 
         if (neu_driver_cache_meta_get(cache, group, tag->name, &value,
-                                      tag_value.metas,
-                                      NEU_TAG_META_SIZE) != 0) {
+                                      &tag_value.metas,
+                                      &tag_value.n_meta) != 0) {
             tag_value.value.type      = NEU_TYPE_ERROR;
             tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
 
@@ -2646,9 +2688,17 @@ static void read_group(int64_t timestamp, int64_t timeout,
         case NEU_TYPE_UINT64:
             switch (tag->option.value64.endian) {
             case NEU_DATATAG_ENDIAN_B64:
+            case NEU_DATATAG_ENDIAN_BB64:
                 value.value.value.u64 = neu_htonll(value.value.value.u64);
                 break;
+            case NEU_DATATAG_ENDIAN_LB64:
+                value.value.value.u64 = neu_htonlb(value.value.value.u64);
+                break;
+            case NEU_DATATAG_ENDIAN_BL64:
+                value.value.value.u64 = neu_htonbl(value.value.value.u64);
+                break;
             case NEU_DATATAG_ENDIAN_L64:
+            case NEU_DATATAG_ENDIAN_LL64:
             default:
                 break;
             }
@@ -2661,12 +2711,8 @@ static void read_group(int64_t timestamp, int64_t timeout,
             (timestamp - value.timestamp) > timeout) {
             if (value.value.type == NEU_TYPE_PTR) {
                 free(value.value.value.ptr.ptr);
-            } else if (value.value.type == NEU_TYPE_CUSTOM) {
-                json_decref(value.value.value.json);
-            } else if (value.value.type == NEU_TYPE_ARRAY_STRING) {
-                for (size_t i = 0; i < value.value.value.strs.length; ++i) {
-                    free(value.value.value.strs.strs[i]);
-                }
+            } else {
+                neu_free_dvalue(&value.value);
             }
             tag_value.value.type      = NEU_TYPE_ERROR;
             tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED;
@@ -2770,8 +2816,8 @@ static void read_group_paginate(int64_t timestamp, int64_t timeout,
         }
 
         if (neu_driver_cache_meta_get(cache, group, tag->name, &value,
-                                      tag_value.metas,
-                                      NEU_TAG_META_SIZE) != 0) {
+                                      &tag_value.metas,
+                                      &tag_value.n_meta) != 0) {
             tag_value.value.type      = NEU_TYPE_ERROR;
             tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
 
@@ -2830,9 +2876,17 @@ static void read_group_paginate(int64_t timestamp, int64_t timeout,
         case NEU_TYPE_UINT64:
             switch (tag->option.value64.endian) {
             case NEU_DATATAG_ENDIAN_B64:
+            case NEU_DATATAG_ENDIAN_BB64:
                 value.value.value.u64 = neu_htonll(value.value.value.u64);
                 break;
+            case NEU_DATATAG_ENDIAN_LB64:
+                value.value.value.u64 = neu_htonlb(value.value.value.u64);
+                break;
+            case NEU_DATATAG_ENDIAN_BL64:
+                value.value.value.u64 = neu_htonbl(value.value.value.u64);
+                break;
             case NEU_DATATAG_ENDIAN_L64:
+            case NEU_DATATAG_ENDIAN_LL64:
             default:
                 break;
             }
@@ -2845,12 +2899,8 @@ static void read_group_paginate(int64_t timestamp, int64_t timeout,
             (timestamp - value.timestamp) > timeout) {
             if (value.value.type == NEU_TYPE_PTR) {
                 free(value.value.value.ptr.ptr);
-            } else if (value.value.type == NEU_TYPE_CUSTOM) {
-                json_decref(value.value.value.json);
-            } else if (value.value.type == NEU_TYPE_ARRAY_STRING) {
-                for (size_t i = 0; i < value.value.value.strs.length; ++i) {
-                    free(value.value.value.strs.strs[i]);
-                }
+            } else {
+                neu_free_dvalue(&value.value);
             }
             tag_value.value.type      = NEU_TYPE_ERROR;
             tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED;

src/adapter/driver/driver_internal.h

@@ -54,7 +54,8 @@ int neu_adapter_driver_del_group(neu_adapter_driver_t *driver,
                                  const char *          name);
 int neu_adapter_driver_group_exist(neu_adapter_driver_t *driver,
                                    const char *          name);
-UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver);
+UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver,
+                                       const char *          filter);
 uint16_t  neu_adapter_driver_group_count(neu_adapter_driver_t *driver);
 uint16_t  neu_adapter_driver_new_group_count(neu_adapter_driver_t *driver,
                                              neu_req_add_gtag_t *  cmd);

src/base/neu_plugin_common.c

@@ -72,35 +72,38 @@ int neu_plugin_op(neu_plugin_t *plugin, neu_reqresp_head_t head, void *data)
                 if (strlen(trace_id) == 32) {
                     trace = neu_otel_create_trace(trace_id, head.ctx, flags,
                                                   trace_state);
-                    scope = neu_otel_add_span(trace);
-                    neu_otel_scope_set_span_name(scope,
-                                                 nng_http_req_get_uri(nng_req));
-                    char new_span_id[36] = { 0 };
-                    neu_otel_new_span_id(new_span_id);
-                    neu_otel_scope_set_span_id(scope, new_span_id);
-                    if (strlen(span_id) == 16) {
-                        neu_otel_scope_set_parent_span_id(scope, span_id);
-                    }
-                    neu_otel_scope_set_span_flags(scope, flags);
-                    neu_otel_scope_set_span_start_time(scope, neu_time_ns());
-
-                    neu_otel_scope_add_span_attr_int(scope, "thread id",
-                                                     (int64_t) pthread_self());
-
-                    neu_otel_scope_add_span_attr_string(scope, "HTTP method",
-                                                        http_method);
-
-                    if (strcmp(http_method, "POST") == 0) {
-                        char * req_data      = NULL;
-                        size_t req_data_size = 0;
-
-                        if (neu_http_get_body((aio), (void **) &req_data,
-                                              &req_data_size) == 0) {
-                            neu_otel_scope_add_span_attr_string(
-                                scope, "HTTP body", req_data);
+                    if (trace) {
+                        scope = neu_otel_add_span(trace);
+                        neu_otel_scope_set_span_name(
+                            scope, nng_http_req_get_uri(nng_req));
+                        char new_span_id[36] = { 0 };
+                        neu_otel_new_span_id(new_span_id);
+                        neu_otel_scope_set_span_id(scope, new_span_id);
+                        if (strlen(span_id) == 16) {
+                            neu_otel_scope_set_parent_span_id(scope, span_id);
                         }
+                        neu_otel_scope_set_span_flags(scope, flags);
+                        neu_otel_scope_set_span_start_time(scope,
+                                                           neu_time_ns());
 
-                        free(req_data);
+                        neu_otel_scope_add_span_attr_int(
+                            scope, "thread id", (int64_t) pthread_self());
+
+                        neu_otel_scope_add_span_attr_string(
+                            scope, "HTTP method", http_method);
+
+                        if (strcmp(http_method, "POST") == 0) {
+                            char * req_data      = NULL;
+                            size_t req_data_size = 0;
+
+                            if (neu_http_get_body((aio), (void **) &req_data,
+                                                  &req_data_size) == 0) {
+                                neu_otel_scope_add_span_attr_string(
+                                    scope, "HTTP body", req_data);
+                            }
+
+                            free(req_data);
+                        }
                     }
                 }
             }
@@ -119,26 +122,29 @@ int neu_plugin_op(neu_plugin_t *plugin, neu_reqresp_head_t head, void *data)
                 if (strlen(trace_id) == 32) {
                     trace = neu_otel_create_trace(trace_id, head.ctx, flags,
                                                   trace_state);
-                    scope = neu_otel_add_span(trace);
-                    neu_otel_scope_set_span_name(scope, "MQTT command");
-                    char new_span_id[36] = { 0 };
-                    neu_otel_new_span_id(new_span_id);
-                    neu_otel_scope_set_span_id(scope, new_span_id);
-                    if (strlen(span_id) == 16) {
-                        neu_otel_scope_set_parent_span_id(scope, span_id);
-                    }
-                    neu_otel_scope_set_span_flags(scope, flags);
-                    neu_otel_scope_set_span_start_time(scope, neu_time_ns());
+                    if (trace) {
+                        scope = neu_otel_add_span(trace);
+                        neu_otel_scope_set_span_name(scope, "MQTT command");
+                        char new_span_id[36] = { 0 };
+                        neu_otel_new_span_id(new_span_id);
+                        neu_otel_scope_set_span_id(scope, new_span_id);
+                        if (strlen(span_id) == 16) {
+                            neu_otel_scope_set_parent_span_id(scope, span_id);
+                        }
+                        neu_otel_scope_set_span_flags(scope, flags);
+                        neu_otel_scope_set_span_start_time(scope,
+                                                           neu_time_ns());
 
-                    neu_otel_scope_add_span_attr_int(scope, "thread id",
-                                                     (int64_t) pthread_self());
+                        neu_otel_scope_add_span_attr_int(
+                            scope, "thread id", (int64_t) pthread_self());
 
-                    neu_otel_scope_add_span_attr_string(
-                        scope, "MQTT command uuid", d_mqtt->uuid);
-
-                    if (d_mqtt->payload) {
                         neu_otel_scope_add_span_attr_string(
-                            scope, "MQTT command payload", d_mqtt->payload);
+                            scope, "MQTT command uuid", d_mqtt->uuid);
+
+                        if (d_mqtt->payload) {
+                            neu_otel_scope_add_span_attr_string(
+                                scope, "MQTT command payload", d_mqtt->payload);
+                        }
                     }
                 }
             }
@@ -157,24 +163,28 @@ int neu_plugin_op(neu_plugin_t *plugin, neu_reqresp_head_t head, void *data)
                         uint32_t flags = 0;
                         trace = neu_otel_create_trace(trace_id, head.ctx, flags,
                                                       trace_state);
-                        scope = neu_otel_add_span(trace);
-                        neu_otel_scope_set_span_name(scope, "ekuiper command");
-                        char new_span_id[36] = { 0 };
-                        neu_otel_new_span_id(new_span_id);
-                        neu_otel_scope_set_span_id(scope, new_span_id);
-                        if (strlen(span_id) == 16) {
-                            neu_otel_scope_set_parent_span_id(scope, span_id);
+                        if (trace) {
+                            scope = neu_otel_add_span(trace);
+                            neu_otel_scope_set_span_name(scope,
+                                                         "ekuiper command");
+                            char new_span_id[36] = { 0 };
+                            neu_otel_new_span_id(new_span_id);
+                            neu_otel_scope_set_span_id(scope, new_span_id);
+                            if (strlen(span_id) == 16) {
+                                neu_otel_scope_set_parent_span_id(scope,
+                                                                  span_id);
+                            }
+                            neu_otel_scope_set_span_flags(scope, flags);
+                            neu_otel_scope_set_span_start_time(scope,
+                                                               neu_time_ns());
+
+                            neu_otel_scope_add_span_attr_int(
+                                scope, "thread id", (int64_t) pthread_self());
+
+                            neu_otel_scope_add_span_attr_string(
+                                scope, "ekuiper command playload",
+                                (char *) head.ctx + 48);
                         }
-                        neu_otel_scope_set_span_flags(scope, flags);
-                        neu_otel_scope_set_span_start_time(scope,
-                                                           neu_time_ns());
-
-                        neu_otel_scope_add_span_attr_int(
-                            scope, "thread id", (int64_t) pthread_self());
-
-                        neu_otel_scope_add_span_attr_string(
-                            scope, "ekuiper command playload",
-                            (char *) head.ctx + 48);
                     }
                 }
             }

src/base/tag.c

@@ -262,21 +262,35 @@ int neu_datatag_parse_addr_option(const neu_datatag_t *      datatag,
     case NEU_TYPE_UINT64: {
         char *op = find_last_character(datatag->address, '#');
 
-        option->value64.endian = NEU_DATATAG_ENDIAN_L64;
+        option->value64.endian     = NEU_DATATAG_ENDIAN_L64;
+        option->value64.is_default = true;
         if (op != NULL) {
-            char e = 0;
-            sscanf(op, "#%c", &e);
+            char e1 = 0;
+            char e2 = 0;
+            int  n  = sscanf(op, "#%c%c", &e1, &e2);
 
-            switch (e) {
-            case 'B':
-                option->value64.endian = NEU_DATATAG_ENDIAN_B64;
-                break;
-            case 'L':
-                option->value64.endian = NEU_DATATAG_ENDIAN_L64;
-                break;
-            default:
-                option->value64.endian = NEU_DATATAG_ENDIAN_L64;
-                break;
+            if (n == 2) {
+                if (e1 == 'B' && e2 == 'B') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_BB64;
+                    option->value64.is_default = false;
+                } else if (e1 == 'B' && e2 == 'L') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_BL64;
+                    option->value64.is_default = false;
+                } else if (e1 == 'L' && e2 == 'L') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_LL64;
+                    option->value64.is_default = false;
+                } else if (e1 == 'L' && e2 == 'B') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_LB64;
+                    option->value64.is_default = false;
+                }
+            } else if (n == 1) {
+                if (e1 == 'B') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_B64;
+                    option->value64.is_default = false;
+                } else if (e1 == 'L') {
+                    option->value64.endian     = NEU_DATATAG_ENDIAN_L64;
+                    option->value64.is_default = false;
+                }
             }
         }
 

src/core/manager.c

@@ -435,7 +435,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         neu_resp_error_t      e   = { 0 };
 
         UT_array *nodes = neu_manager_get_nodes(
-            manager, NEU_NA_TYPE_DRIVER | NEU_NA_TYPE_APP, cmd->plugin, "");
+            manager, NEU_NA_TYPE_DRIVER | NEU_NA_TYPE_APP, cmd->plugin, "",
+            false, false, 0, false, 0, "");
 
         if (nodes != NULL) {
             if (utarray_len(nodes) > 0) {
@@ -616,7 +617,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         }
 
         UT_array *nodes = neu_manager_get_nodes(
-            manager, NEU_NA_TYPE_DRIVER | NEU_NA_TYPE_APP, module_name, "");
+            manager, NEU_NA_TYPE_DRIVER | NEU_NA_TYPE_APP, module_name, "",
+            false, false, 0, false, 0, "");
 
         if (nodes != NULL) {
             if (utarray_len(nodes) > 0) {
@@ -866,9 +868,11 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         break;
     }
     case NEU_REQ_GET_NODE: {
-        neu_req_get_node_t *cmd = (neu_req_get_node_t *) &header[1];
-        UT_array *          nodes =
-            neu_manager_get_nodes(manager, cmd->type, cmd->plugin, cmd->node);
+        neu_req_get_node_t *cmd   = (neu_req_get_node_t *) &header[1];
+        UT_array *          nodes = neu_manager_get_nodes(
+            manager, cmd->type, cmd->plugin, cmd->node, cmd->query.s_delay,
+            cmd->query.q_state, cmd->query.state, cmd->query.q_link,
+            cmd->query.link, cmd->query.q_group_name);
         neu_resp_get_node_t resp = { .nodes = nodes };
 
         header->type = NEU_RESP_GET_NODE;

src/core/manager_internal.c

@@ -114,9 +114,13 @@ int neu_manager_del_node(neu_manager_t *manager, const char *node_name)
 }
 
 UT_array *neu_manager_get_nodes(neu_manager_t *manager, int type,
-                                const char *plugin, const char *node)
+                                const char *plugin, const char *node,
+                                bool sort_delay, bool q_state, int state,
+                                bool q_link, int link, const char *q_group_name)
 {
-    return neu_node_manager_filter(manager->node_manager, type, plugin, node);
+    return neu_node_manager_filter(manager->node_manager, type, plugin, node,
+                                   sort_delay, q_state, state, q_link, link,
+                                   q_group_name);
 }
 
 int neu_manager_update_node_name(neu_manager_t *manager, const char *node,
@@ -182,7 +186,7 @@ UT_array *neu_manager_get_driver_group(neu_manager_t *manager)
         neu_adapter_t *adapter =
             neu_node_manager_find(manager->node_manager, driver->node);
         UT_array *groups =
-            neu_adapter_driver_get_group((neu_adapter_driver_t *) adapter);
+            neu_adapter_driver_get_group((neu_adapter_driver_t *) adapter, "");
 
         utarray_foreach(groups, neu_resp_group_info_t *, g)
         {

src/core/manager_internal.h

@@ -30,7 +30,7 @@
 #include "subscribe.h"
 #include "utils/log.h"
 
-typedef struct neu_manager {
+struct neu_manager {
     int server_fd;
 
     neu_events_t *  events;
@@ -45,7 +45,7 @@ typedef struct neu_manager {
     int64_t timestamp_lev_manager;
 
     int log_level;
-} neu_manager_t;
+};
 
 int       neu_manager_add_plugin(neu_manager_t *manager, const char *library);
 int       neu_manager_del_plugin(neu_manager_t *manager, const char *plugin);
@@ -56,7 +56,10 @@ int       neu_manager_add_node(neu_manager_t *manager, const char *node_name,
                                neu_node_running_state_e state, bool load);
 int       neu_manager_del_node(neu_manager_t *manager, const char *node_name);
 UT_array *neu_manager_get_nodes(neu_manager_t *manager, int type,
-                                const char *plugin, const char *node);
+                                const char *plugin, const char *node,
+                                bool sort_delay, bool q_state, int state,
+                                bool q_link, int link,
+                                const char *q_group_name);
 int       neu_manager_update_node_name(neu_manager_t *manager, const char *node,
                                        const char *new_name);
 int neu_manager_update_group_name(neu_manager_t *manager, const char *driver,

src/core/node_manager.c

@@ -194,8 +194,24 @@ UT_array *neu_node_manager_get(neu_node_manager_t *mgr, int type)
     return array;
 }
 
+static int neu_resp_node_info_sort(const void *a, const void *b)
+{
+    const neu_resp_node_info_t *info_a = (const neu_resp_node_info_t *) a;
+    const neu_resp_node_info_t *info_b = (const neu_resp_node_info_t *) b;
+
+    if (info_a->delay < info_b->delay) {
+        return -1;
+    } else if (info_a->delay > info_b->delay) {
+        return 1;
+    }
+    return 0;
+}
+
 UT_array *neu_node_manager_filter(neu_node_manager_t *mgr, int type,
-                                  const char *plugin, const char *node)
+                                  const char *plugin, const char *node,
+                                  bool sort_delay, bool q_state, int state,
+                                  bool q_link, int link,
+                                  const char *q_group_name)
 {
     UT_array *     array = NULL;
     UT_icd         icd   = { sizeof(neu_resp_node_info_t), NULL, NULL, NULL };
@@ -215,14 +231,57 @@ UT_array *neu_node_manager_filter(neu_node_manager_t *mgr, int type,
                     strstr(el->adapter->name, node) == NULL) {
                     continue;
                 }
+                if (q_state) {
+                    if (el->adapter->state !=
+                        (neu_node_running_state_e) state) {
+                        continue;
+                    }
+                }
+                if (q_link) {
+                    neu_node_state_t node_state =
+                        neu_adapter_get_state(el->adapter);
+                    if (node_state.link != (neu_node_link_state_e) link) {
+                        continue;
+                    }
+                }
+
+                if (strlen(q_group_name) > 0) {
+                    if (strstr(el->adapter->name, q_group_name) == NULL) {
+                        UT_array *groups =
+                            neu_adapter_get_groups(el->adapter, q_group_name);
+                        if (NULL == groups || utarray_len(groups) == 0) {
+                            if (groups != NULL) {
+                                utarray_free(groups);
+                            }
+                            continue;
+                        } else {
+                            utarray_free(groups);
+                        }
+                    }
+                }
+
                 neu_resp_node_info_t info = { 0 };
                 strcpy(info.node, el->adapter->name);
                 strcpy(info.plugin, el->adapter->module->module_name);
+                if (sort_delay) {
+                    neu_metric_entry_t *e = NULL;
+                    if (NULL != el->adapter->metrics) {
+                        HASH_FIND_STR(el->adapter->metrics->entries,
+                                      NEU_METRIC_LAST_RTT_MS, e);
+                    }
+                    info.delay = NULL != e ? e->value : 0;
+                } else {
+                    info.delay = 0;
+                }
                 utarray_push_back(array, &info);
             }
         }
     }
 
+    if (sort_delay) {
+        utarray_sort(array, neu_resp_node_info_sort);
+    }
+
     return array;
 }
 

src/core/node_manager.h

@@ -49,7 +49,10 @@ uint16_t neu_node_manager_size(neu_node_manager_t *mgr);
 // neu_resp_node_info array
 UT_array *neu_node_manager_get(neu_node_manager_t *mgr, int type);
 UT_array *neu_node_manager_filter(neu_node_manager_t *mgr, int type,
-                                  const char *plugin, const char *node);
+                                  const char *plugin, const char *node,
+                                  bool sort_delay, bool q_state, int state,
+                                  bool q_link, int link,
+                                  const char *q_group_name);
 UT_array *neu_node_manager_get_all(neu_node_manager_t *mgr);
 
 // neu_adapter_t array

src/core/storage.c

@@ -18,6 +18,7 @@
  **/
 #include "errcodes.h"
 #include "utils/log.h"
+#include "utils/time.h"
 
 #include "adapter/storage.h"
 #include "storage.h"
@@ -140,6 +141,8 @@ int manager_load_node(neu_manager_t *manager)
         return -1;
     }
 
+    int i = 0;
+
     utarray_foreach(node_infos, neu_persist_node_info_t *, node_info)
     {
         rv                    = neu_manager_add_node(manager, node_info->name,
@@ -149,6 +152,10 @@ int manager_load_node(neu_manager_t *manager)
         nlog_notice("load adapter %s type:%d, name:%s plugin:%s state:%d",
                     ok_or_err, node_info->type, node_info->name,
                     node_info->plugin_name, node_info->state);
+        i++;
+        if (i % 10 == 0) {
+            neu_msleep(10);
+        }
     }
 
     utarray_free(node_infos);
@@ -160,6 +167,8 @@ int manager_load_subscribe(neu_manager_t *manager)
     UT_array *nodes =
         neu_node_manager_get(manager->node_manager, NEU_NA_TYPE_APP);
 
+    int i = 0;
+
     utarray_foreach(nodes, neu_resp_node_info_t *, node)
     {
         int       rv        = 0;
@@ -186,6 +195,10 @@ int manager_load_subscribe(neu_manager_t *manager)
                                                info->group_name, app_port,
                                                info->params, info->static_tags);
                 }
+                i++;
+                if (i % 10 == 0) {
+                    neu_msleep(10);
+                }
             }
 
             utarray_free(sub_infos);

src/main.c

@@ -35,15 +35,15 @@
 #include "daemon.h"
 #include "version.h"
 
-static bool           exit_flag         = false;
-static neu_manager_t *g_manager         = NULL;
-zlog_category_t *     neuron            = NULL;
-bool                  disable_jwt       = false;
-bool                  sub_filter_err    = false;
-int                   default_log_level = ZLOG_LEVEL_NOTICE;
-char                  host_port[32]     = { 0 };
-char                  g_status[32]      = { 0 };
-static bool           sig_trigger       = false;
+static bool      exit_flag         = false;
+neu_manager_t *  g_manager         = NULL;
+zlog_category_t *neuron            = NULL;
+bool             disable_jwt       = false;
+bool             sub_filter_err    = false;
+int              default_log_level = ZLOG_LEVEL_NOTICE;
+char             host_port[32]     = { 0 };
+char             g_status[32]      = { 0 };
+static bool      sig_trigger       = false;
 
 int64_t global_timestamp = 0;
 

src/otel/otel_manager.c

@@ -56,6 +56,8 @@ typedef struct {
     int64_t                                     ts;
     UT_array *                                  scopes;
     pthread_mutex_t                             mutex;
+    ProtobufCBinaryData                         internal_parent_span;
+    bool                                        report_flag;
 } trace_ctx_t;
 
 typedef struct {
@@ -158,6 +160,18 @@ static int parse_tracestate(const char *tracestate, trace_kv_t *kvs,
     return 1;
 }
 
+void neu_otel_set_internal_parent_span(neu_otel_trace_ctx ctx)
+{
+    trace_ctx_t *trace_ctx = (trace_ctx_t *) ctx;
+    pthread_mutex_lock(&trace_ctx->mutex);
+    if (utarray_len(trace_ctx->scopes) > 0) {
+        trace_scope_t *scope =
+            *(trace_scope_t **) utarray_back(trace_ctx->scopes);
+        trace_ctx->internal_parent_span = scope->span->span_id;
+    }
+    pthread_mutex_unlock(&trace_ctx->mutex);
+}
+
 void neu_otel_free_span(Opentelemetry__Proto__Trace__V1__Span *span)
 {
     for (size_t i = 0; i < span->n_attributes; i++) {
@@ -186,6 +200,19 @@ void neu_otel_free_span(Opentelemetry__Proto__Trace__V1__Span *span)
 neu_otel_trace_ctx neu_otel_create_trace(const char *trace_id, void *req_ctx,
                                          uint32_t flags, const char *tracestate)
 {
+    trace_ctx_table_ele_t *find = NULL;
+
+    pthread_mutex_lock(&table_mutex);
+
+    HASH_FIND(hh, traces_table, &req_ctx, sizeof(req_ctx), find);
+
+    if (find) {
+        pthread_mutex_unlock(&table_mutex);
+        return NULL;
+    }
+
+    pthread_mutex_unlock(&table_mutex);
+
     trace_ctx_t *ctx = calloc(1, sizeof(trace_ctx_t));
     opentelemetry__proto__trace__v1__traces_data__init(&ctx->trace_data);
     strncpy((char *) ctx->trace_id, trace_id, 64);
@@ -458,7 +485,44 @@ neu_otel_trace_ctx neu_otel_find_trace(void *req_ctx)
     pthread_mutex_unlock(&table_mutex);
 
     if (find) {
-        return (void *) find->ctx;
+        if (find->ctx->final &&
+            find->ctx->span_num ==
+                find->ctx->trace_data.resource_spans[0]
+                    ->scope_spans[0]
+                    ->n_spans &&
+            find->ctx->expected_span_num <= 0) {
+            return NULL;
+        } else {
+            return (void *) find->ctx;
+        }
+    } else {
+        return NULL;
+    }
+}
+
+neu_otel_trace_ctx neu_otel_find_trace2(void *req_ctx)
+{
+    trace_ctx_table_ele_t *find = NULL;
+
+    pthread_mutex_lock(&table_mutex);
+
+    HASH_FIND(hh, traces_table, &req_ctx, sizeof(req_ctx), find);
+
+    pthread_mutex_unlock(&table_mutex);
+
+    if (find) {
+        if ((find->ctx->final &&
+             find->ctx->span_num ==
+                 find->ctx->trace_data.resource_spans[0]
+                     ->scope_spans[0]
+                     ->n_spans &&
+             find->ctx->expected_span_num <= 0) ||
+            find->ctx->report_flag) {
+            return NULL;
+        } else {
+            find->ctx->report_flag = true;
+            return (void *) find->ctx;
+        }
     } else {
         return NULL;
     }
@@ -476,6 +540,16 @@ void neu_otel_trace_set_expected_span_num(neu_otel_trace_ctx ctx, uint32_t num)
     trace_ctx->expected_span_num = num;
 }
 
+void neu_otel_trace_reduce_expected_span_num(neu_otel_trace_ctx ctx,
+                                             uint32_t           num)
+{
+    trace_ctx_t *trace_ctx = (trace_ctx_t *) ctx;
+    trace_ctx->expected_span_num -= num;
+    if (trace_ctx->expected_span_num <= 0) {
+        trace_ctx->final = true;
+    }
+}
+
 uint8_t *neu_otel_get_trace_id(neu_otel_trace_ctx ctx)
 {
     trace_ctx_t *trace_ctx = (trace_ctx_t *) ctx;
@@ -670,7 +744,11 @@ neu_otel_scope_ctx neu_otel_add_span2(neu_otel_trace_ctx ctx,
     scope->span->flags         = trace_ctx->flags;
     neu_otel_scope_set_span_name(scope, span_name);
     neu_otel_scope_set_span_id(scope, span_id);
-    if (scope->span_index != 0) {
+    if (trace_ctx->internal_parent_span.data != NULL) {
+        neu_otel_scope_set_parent_span_id2(scope,
+                                           trace_ctx->internal_parent_span.data,
+                                           trace_ctx->internal_parent_span.len);
+    } else if (scope->span_index != 0) {
         neu_otel_scope_set_parent_span_id2(
             scope,
             trace_ctx->trace_data.resource_spans[0]
@@ -932,8 +1010,10 @@ int neu_otel_trace_pack(neu_otel_trace_ctx ctx, uint8_t *out)
 
 void neu_otel_new_span_id(char *id)
 {
+    int64_t p_id = (int64_t) pthread_self();
     for (int i = SPAN_ID_LENGTH - 1; i >= 0; i--) {
-        id[i] = ID_CHARSET[rand() % 16];
+        int64_t rand_id = (int64_t) rand() + neu_time_ns() + p_id;
+        id[i]           = ID_CHARSET[rand_id % 16];
     }
     id[SPAN_ID_LENGTH] = '\0';
 }
@@ -984,19 +1064,25 @@ void neu_otel_split_traceparent(const char *in, char *trace_id, char *span_id,
 static int otel_timer_cb(void *data)
 {
     (void) data;
-
+    int                    batch_size = 50;
+    int                    index      = 0;
     trace_ctx_table_ele_t *el = NULL, *tmp = NULL;
 
     pthread_mutex_lock(&table_mutex);
 
     HASH_ITER(hh, traces_table, el, tmp)
     {
-        if (el->ctx->final &&
-            el->ctx->span_num ==
-                el->ctx->trace_data.resource_spans[0]
-                    ->scope_spans[0]
-                    ->n_spans &&
-            el->ctx->expected_span_num <= 0) {
+        if (neu_time_ms() - el->ctx->ts >= TRACE_TIME_OUT) {
+            nlog_debug("trace:%s time out", (char *) el->ctx->trace_id);
+            HASH_DEL(traces_table, el);
+            neu_otel_free_trace(el->ctx);
+            free(el);
+        } else if (el->ctx->final &&
+                   el->ctx->span_num ==
+                       el->ctx->trace_data.resource_spans[0]
+                           ->scope_spans[0]
+                           ->n_spans &&
+                   el->ctx->expected_span_num <= 0) {
             int data_size = neu_otel_trace_pack_size(el->ctx);
 
             uint8_t *data_buf = calloc(1, data_size);
@@ -1009,12 +1095,13 @@ static int otel_timer_cb(void *data)
                 HASH_DEL(traces_table, el);
                 neu_otel_free_trace(el->ctx);
                 free(el);
+                index += 1;
+                if (index > batch_size) {
+                    break;
+                }
+            } else {
+                break;
             }
-        } else if (neu_time_ms() - el->ctx->ts >= TRACE_TIME_OUT) {
-            nlog_debug("trace:%s time out", (char *) el->ctx->trace_id);
-            HASH_DEL(traces_table, el);
-            neu_otel_free_trace(el->ctx);
-            free(el);
         }
     }
 
@@ -1035,7 +1122,7 @@ void neu_otel_start()
         param.usr_data = NULL;
 
         param.second      = 0;
-        param.millisecond = 100;
+        param.millisecond = 80;
         param.cb          = otel_timer_cb;
         param.type        = NEU_EVENT_TIMER_BLOCK;
 

src/parser/neu_json_rw.c

@@ -358,31 +358,30 @@ int neu_json_encode_read_resp_ecp(void *json_object, void *param)
 
         tag_elems[0].name      = "name";
         tag_elems[0].t         = NEU_JSON_STR;
-        tag_elems[0].v.val_str = p_tag->name;
+        tag_elems[0].v.val_str = p_tag[i].name;
 
-        if (p_tag->error != 0) {
+        if (p_tag[i].error != 0) {
             continue;
         } else {
             tag_elems[1].name      = "value";
-            tag_elems[1].t         = p_tag->t;
-            tag_elems[1].v         = p_tag->value;
-            tag_elems[1].precision = p_tag->precision;
+            tag_elems[1].t         = p_tag[i].t;
+            tag_elems[1].v         = p_tag[i].value;
+            tag_elems[1].precision = p_tag[i].precision;
 
             tag_elems[2].name      = "type";
             tag_elems[2].t         = NEU_JSON_INT;
-            tag_elems[2].v.val_int = neu_json_type_transfer(p_tag->t);
+            tag_elems[2].v.val_int = neu_json_type_transfer(p_tag[i].t);
         }
 
-        for (int k = 0; k < p_tag->n_meta; k++) {
-            tag_elems[3 + k].name = p_tag->metas[k].name;
-            tag_elems[3 + k].t    = p_tag->metas[k].t;
-            tag_elems[3 + k].v    = p_tag->metas[k].value;
+        for (int k = 0; k < p_tag[i].n_meta; k++) {
+            tag_elems[3 + k].name = p_tag[i].metas[k].name;
+            tag_elems[3 + k].t    = p_tag[i].metas[k].t;
+            tag_elems[3 + k].v    = p_tag[i].metas[k].value;
         }
 
-        tag_array =
-            neu_json_encode_array(tag_array, tag_elems, 3 + p_tag->n_meta);
-        has_data = 1;
-        p_tag++;
+        tag_array = neu_json_encode_array_ecp(tag_array, tag_elems,
+                                              3 + p_tag[i].n_meta);
+        has_data  = 1;
     }
 
     neu_json_elem_t resp_elems[] = { {

src/utils/json.c

@@ -346,6 +346,136 @@ static json_t *encode_object(json_t *object, neu_json_elem_t ele)
     return ob;
 }
 
+static json_t *encode_object_ecp(json_t *object, neu_json_elem_t ele)
+{
+    json_t *ob = object;
+
+    switch (ele.t) {
+    case NEU_JSON_BIT:
+        json_object_set_new(ob, ele.name, json_integer(ele.v.val_bit));
+        break;
+    case NEU_JSON_INT:
+        json_object_set_new(ob, ele.name, json_integer(ele.v.val_int));
+        break;
+    case NEU_JSON_STR:
+        json_object_set_new(ob, ele.name, json_string(ele.v.val_str));
+        break;
+    case NEU_JSON_FLOAT: {
+        double t = ele.v.val_float;
+        if (ele.precision == 0 && ele.bias == 0) {
+            t = format_tag_value(ele.v.val_float);
+        }
+        json_object_set_new(ob, ele.name, json_realp(t, ele.precision));
+        break;
+    }
+    case NEU_JSON_DOUBLE:
+        json_object_set_new(ob, ele.name,
+                            json_realp(ele.v.val_double, ele.precision));
+        break;
+    case NEU_JSON_BOOL:
+        json_object_set_new(ob, ele.name, json_boolean(ele.v.val_bool));
+        break;
+
+#define ENCODE_ARRAY_TO_STRING(TYPE, FIELD, DATA, FORMAT)                      \
+    case TYPE: {                                                               \
+        size_t buffer_size = 2;                                                \
+        for (int i = 0; i < ele.v.FIELD.length; i++) {                         \
+            buffer_size += snprintf(NULL, 0, FORMAT, ele.v.FIELD.DATA[i]) + 2; \
+        }                                                                      \
+        char *array_str = (char *) malloc(buffer_size);                        \
+        if (array_str == NULL) {                                               \
+            return NULL;                                                       \
+        }                                                                      \
+        char *ptr = array_str;                                                 \
+        *ptr++    = '[';                                                       \
+        for (int i = 0; i < ele.v.FIELD.length; i++) {                         \
+            int len = sprintf(ptr, FORMAT, ele.v.FIELD.DATA[i]);               \
+            ptr += len;                                                        \
+            if (i < ele.v.FIELD.length - 1) {                                  \
+                *ptr++ = ',';                                                  \
+                *ptr++ = ' ';                                                  \
+            }                                                                  \
+        }                                                                      \
+        *ptr++ = ']';                                                          \
+        *ptr   = '\0';                                                         \
+        json_object_set_new(ob, ele.name, json_string(array_str));             \
+        free(array_str);                                                       \
+        break;                                                                 \
+    }
+
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_BOOL, val_array_bool, bools, "%d")
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_INT8, val_array_int8, i8s,
+                               "%" PRId8)
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_UINT8, val_array_uint8, u8s,
+                               "%" PRIu8)
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_INT16, val_array_int16, i16s,
+                               "%" PRId16)
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_UINT16, val_array_uint16, u16s,
+                               "%" PRIu16)
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_INT32, val_array_int32, i32s,
+                               "%" PRId32)
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_UINT32, val_array_uint32, u32s,
+                               "%" PRIu32)
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_INT64, val_array_int64, i64s,
+                               "%" PRId64)
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_UINT64, val_array_uint64, u64s,
+                               "%" PRIu64)
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_FLOAT, val_array_float, f32s,
+                               "%.6f")
+        ENCODE_ARRAY_TO_STRING(NEU_JSON_ARRAY_DOUBLE, val_array_double, f64s,
+                               "%.6f")
+
+#undef ENCODE_ARRAY_TO_STRING
+
+    case NEU_JSON_ARRAY_STR: {
+        size_t buffer_size = 2;
+        for (int i = 0; i < ele.v.val_array_str.length; i++) {
+            buffer_size +=
+                snprintf(NULL, 0, "\"%s\"", ele.v.val_array_str.p_strs[i]) + 2;
+        }
+
+        char *array_str = (char *) malloc(buffer_size);
+        if (array_str == NULL) {
+            return NULL;
+        }
+
+        char *ptr = array_str;
+        *ptr++    = '[';
+
+        for (int i = 0; i < ele.v.val_array_str.length; i++) {
+            int len = sprintf(ptr, "\"%s\"", ele.v.val_array_str.p_strs[i]);
+            ptr += len;
+
+            if (i < ele.v.val_array_str.length - 1) {
+                *ptr++ = ',';
+                *ptr++ = ' ';
+            }
+        }
+
+        *ptr++ = ']';
+        *ptr   = '\0';
+
+        json_object_set_new(ob, ele.name, json_string(array_str));
+        free(array_str);
+        break;
+    }
+    case NEU_JSON_OBJECT: {
+        char *json_str = json_dumps(ele.v.val_object, JSON_ENCODE_ANY);
+        if (json_str == NULL) {
+            return NULL;
+        }
+
+        json_object_set_new(ob, ele.name, json_string(json_str));
+        free(json_str);
+        break;
+    }
+    default:
+        break;
+    }
+
+    return ob;
+}
+
 static int decode_object(json_t *root, neu_json_elem_t *ele)
 {
     json_t *ob = NULL;
@@ -910,6 +1040,21 @@ void *neu_json_encode_array(void *array, neu_json_elem_t *t, int n)
     return array;
 }
 
+void *neu_json_encode_array_ecp(void *array, neu_json_elem_t *t, int n)
+{
+    if (array == NULL) {
+        array = json_array();
+    }
+
+    json_t *ob = json_object();
+    for (int j = 0; j < n; j++) {
+        encode_object_ecp(ob, t[j]);
+    }
+
+    json_array_append_new(array, ob);
+    return array;
+}
+
 void *neu_json_encode_new()
 {
     return json_object();

tests/ft/app/test_ekuiper.py

@@ -25,7 +25,7 @@ PLUGIN = "eKuiper"
 DRIVER = "modbus"
 DRIVER_PORT = random_port()
 GROUP = "group"
-INTERVAL = 100
+INTERVAL = 200
 TAGS = [
     {
         "name": "tag0",
@@ -126,7 +126,7 @@ def conf_bad_port(conf_base):
 
 @pytest.fixture(scope="function")
 def mocker():
-    mock = Mocker(timeout=1000)
+    mock = Mocker(timeout=2000)
     yield mock
     mock.disconnect()
 
@@ -159,7 +159,8 @@ class Mocker:
 
     def recv(self):
         msg = self.sock.recv()
-        msg = msg[26:]
+        if msg[0:2] == b'\x0A\xCE':
+            msg = msg[26:]
         return json.loads(msg.decode())
 
     def send(self, data):

tests/ft/driver/test_modbus.py

@@ -582,12 +582,6 @@ class TestModbus:
         assert error.NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH == response.json()[
             'error']
 
-        response = api.write_tag(
-            node=param[0], group='group', tag=hold_float[0]['name'], value=1)
-        assert 400 == response.status_code
-        assert error.NEU_ERR_PLUGIN_TAG_TYPE_MISMATCH == response.json()[
-            'error']
-
         response = api.write_tags(node=param[0], group='group', tag_values=[
             {"tag": hold_int16[0]['name'], "value": 32768},
             {"tag": hold_uint16[0]['name'], "value": 2},

tests/ft/http_api/test_http_api.py

@@ -610,6 +610,39 @@ class TestHttp:
         response = api.get_status()
         assert 200 == response.status_code
 
+    @description(given="running neuron", when="get node or group by filter", then="success")
+    def test_get_node_or_group_by_filter(self):
+        node_1 = "test1"
+        node_2 = "test2"
+        group_1 = "abcd1"
+        group_2 = "abdc2"
+        api.add_node_check(node_1, 'Modbus TCP')
+        api.add_node_check(node_2, 'Modbus TCP')
+        api.add_group_check(node_1, group_1, 1000)
+        api.add_group_check(node_1, group_2, 1000)
+        api.add_group_check(node_2, group_1, 1000)
+        # api.add_group_check(node_2, group_2, 1000)
+
+        response = api.get_nodes(1)
+        assert 2 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="dc")
+        assert 1 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="ab")
+        assert 2 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="test")
+        assert 2 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="test1")
+        assert 1 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="1234")
+        assert 0 == len(response.json()["nodes"])
+        response = api.get_group(node=node_1)
+        assert 2 == len(response.json()["groups"])
+        response = api.get_group(node=node_1, group="1")
+        assert 1 == len(response.json()["groups"])
+        response = api.get_group(node=node_2)
+        assert 1 == len(response.json()["groups"])
+
+
     @description(given="running neuron", when="test jwt error", then="failed")
     def test_jwt_err(self):
         response = api.change_password(new_password='123456', jwt='invalid')
@@ -629,3 +662,5 @@ class TestHttp:
 
         response = api.delete_virtual_license(jwt='invalid')
         assert 404 == response.status_code
+
+

tests/ft/neuron/api.py

@@ -79,8 +79,11 @@ def del_node(node, jwt=config.default_jwt):
     return requests.delete(url=config.BASE_URL + '/api/v2/node', headers={"Authorization": jwt}, json={"name": node})
 
 
-def get_nodes(type, jwt=config.default_jwt):
-    return requests.get(url=config.BASE_URL + '/api/v2/node', headers={"Authorization": jwt}, params={"type": type})
+def get_nodes(type, jwt=config.default_jwt, group=""):
+    if group == "":
+        return requests.get(url=config.BASE_URL + '/api/v2/node', headers={"Authorization": jwt}, params={"type": type})
+    else:
+        return requests.get(url=config.BASE_URL + '/api/v2/node?group=' + group, headers={"Authorization": jwt}, params={"type": type})
 
 
 @gen_check
@@ -124,8 +127,13 @@ def update_group(node, group, new_name="", interval=0):
 
 
 @gen_check
-def get_group(node=""):
-    return requests.get(url=config.BASE_URL + f'/api/v2/group?node={node}', headers={"Authorization": config.default_jwt})
+def get_group(node="", group=""):
+    if group == "":
+        return requests.get(url=config.BASE_URL + f'/api/v2/group?node={node}', headers={"Authorization": config.default_jwt})
+    else:
+        return requests.get(url=config.BASE_URL + f'/api/v2/group?node={node}&group={group}', headers={"Authorization": config.default_jwt})
+
+
 
 
 @gen_check

tests/ut/mqtt_schema_test.cc

@@ -29,10 +29,10 @@ TEST(validate_success, schema)
     EXPECT_EQ(vts[2].vt, MQTT_SCHEMA_GROUP_NAME);
 
     EXPECT_STREQ(vts[3].name, "tags");
-    EXPECT_EQ(vts[3].vt, MQTT_SCHEMA_TAG_VALUES);
+    EXPECT_EQ(vts[3].vt, MQTT_SCHEMA_TAGVALUES);
 
     EXPECT_STREQ(vts[4].name, "static");
-    EXPECT_EQ(vts[4].vt, MQTT_SCHEMA_STATIC_TAG_VALUES);
+    EXPECT_EQ(vts[4].vt, MQTT_SCHEMA_STATIC_TAGS);
 
     EXPECT_STREQ(vts[5].name, "errors");
     EXPECT_EQ(vts[5].vt, MQTT_SCHEMA_TAG_ERRORS);
@@ -44,6 +44,51 @@ TEST(validate_success, schema)
     free(vts);
 }
 
+TEST(validate_deep_success, schema)
+{
+    const char *schema = "{\"timestamp\": \"${timestamp}\", \"object\": "
+                         "{\"group\":\"${group}\", \"sub_object\": "
+                         "{\"tags\":\"${tags}\", \"cus\":\"aabb\"}}}";
+    mqtt_schema_vt_t *vts;
+    size_t            n_vts;
+    int               ret = mqtt_schema_validate(schema, &vts, &n_vts);
+    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(n_vts, 2);
+
+    EXPECT_STREQ(vts[0].name, "timestamp");
+    EXPECT_EQ(vts[0].vt, MQTT_SCHEMA_TIMESTAMP);
+
+    EXPECT_STREQ(vts[1].name, "object");
+    EXPECT_EQ(vts[1].vt, MQTT_SCHEMA_OBJECT);
+    EXPECT_EQ(vts[1].n_sub_vts, 2);
+
+    EXPECT_STREQ(vts[1].sub_vts[0].name, "group");
+    EXPECT_EQ(vts[1].sub_vts[0].vt, MQTT_SCHEMA_GROUP_NAME);
+
+    EXPECT_STREQ(vts[1].sub_vts[1].name, "sub_object");
+    EXPECT_EQ(vts[1].sub_vts[1].vt, MQTT_SCHEMA_OBJECT);
+    EXPECT_EQ(vts[1].sub_vts[1].n_sub_vts, 2);
+
+    EXPECT_STREQ(vts[1].sub_vts[1].sub_vts[0].name, "tags");
+    EXPECT_EQ(vts[1].sub_vts[1].sub_vts[0].vt, MQTT_SCHEMA_TAGS);
+
+    EXPECT_STREQ(vts[1].sub_vts[1].sub_vts[1].name, "cus");
+    EXPECT_EQ(vts[1].sub_vts[1].sub_vts[1].vt, MQTT_SCHEMA_UD);
+
+    for (size_t i = 0; i < n_vts; i++) {
+        if (vts[i].vt == MQTT_SCHEMA_OBJECT) {
+            for (size_t k = 0; k < vts[i].n_sub_vts; k++) {
+                if (vts[i].sub_vts[k].vt == MQTT_SCHEMA_OBJECT) {
+                    free(vts[i].sub_vts[k].sub_vts);
+                }
+            }
+            free(vts[i].sub_vts);
+        }
+    }
+
+    free(vts);
+}
+
 TEST(validate_failed, schema)
 {
     const char *schema =
@@ -100,6 +145,41 @@ TEST(validate_success, schema_static)
     mqtt_static_free(vts, n_vts);
 }
 
+TEST(schema_encode_deep, schema_encode)
+{
+    const char *schema = "{\"timestamp\": \"${timestamp}\", \"object\": "
+                         "{\"group\":\"${group}\", \"sub_object\": "
+                         "{\"node\":\"${node}\", \"cus\":\"aabb\"}}}";
+    mqtt_schema_vt_t *vts;
+    size_t            n_vts;
+    int               ret = mqtt_schema_validate(schema, &vts, &n_vts);
+    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(n_vts, 2);
+
+    char *               result = NULL;
+    neu_json_read_resp_t tags   = { 0 };
+    ret = mqtt_schema_encode((char *) "driver", (char *) "group", &tags, vts,
+                             n_vts, NULL, 0, &result);
+    EXPECT_EQ(ret, 0);
+    EXPECT_STREQ(result,
+                 "{\"timestamp\": 0, \"object\": {\"group\": \"group\", "
+                 "\"sub_object\": {\"node\": \"driver\", \"cus\": \"aabb\"}}}");
+    free(result);
+
+    for (size_t i = 0; i < n_vts; i++) {
+        if (vts[i].vt == MQTT_SCHEMA_OBJECT) {
+            for (size_t k = 0; k < vts[i].n_sub_vts; k++) {
+                if (vts[i].sub_vts[k].vt == MQTT_SCHEMA_OBJECT) {
+                    free(vts[i].sub_vts[k].sub_vts);
+                }
+            }
+            free(vts[i].sub_vts);
+        }
+    }
+
+    free(vts);
+}
+
 TEST(schema_encode, schema_static)
 {
     const char *schema =
@@ -134,7 +214,7 @@ TEST(schema_encode, schema_static)
     EXPECT_STREQ(
         result,
         "{\"timestamp\": 0, \"node\": \"driver\", \"group\": \"group\", "
-        "\"tags\": [], \"static\": [{\"name\": \"static_tag1\", \"value\": "
+        "\"tags\": {}, \"static\": [{\"name\": \"static_tag1\", \"value\": "
         "\"string\"}, {\"name\": \"static_tag2\", \"value\": 1234}, {\"name\": "
         "\"static_tag3\", \"value\": 11.44}, {\"name\": \"static_tag4\", "
         "\"value\": true}, {\"name\": \"static_tag5\", \"value\": \"[1, 3, "

version

@@ -1 +1 @@
-2.11.0-alpha
+2.11.4