Merge pull request #2637 from fengzeroz/v2.13

version: 2.13.0

.github/workflows/check.yml

@@ -27,7 +27,7 @@ jobs:
 
   cppcheck:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
 
     steps:
       - uses: actions/checkout@v4
@@ -42,7 +42,7 @@ jobs:
 
   build:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
 
     steps:
       - uses: actions/checkout@v4
@@ -65,7 +65,7 @@ jobs:
 
   ut:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
     needs: [build]
 
     steps:
@@ -85,25 +85,9 @@ jobs:
           cmake -DUSE_GCOV=1 .. -DCMAKE_TOOLCHAIN_FILE=../cmake/x86_64-linux-gnu.cmake
           ctest --output-on-failure
 
-      - name: create cov report
-        run: |
-            sudo apt-get update
-            sudo apt-get -y install lcov
-            mkdir -p cov_report
-            ./create_cov_report.sh ut
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          verbose: true
-          fail_ci_if_error: true
-          token: ${{ secrets.CODECOV_TOKEN }}
-          directory: ./cov_report/
-          files: ./cov_report/cov-ut.info
-
   pft:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
     needs: [build]
     strategy:
       matrix:
@@ -149,19 +133,3 @@ jobs:
           else
             pytest -s -v tests/ft/metrics/"test_metrics.py"          
           fi
-
-      - name: create cov report
-        run: |
-            sudo apt-get update
-            sudo apt-get -y install lcov
-            mkdir -p cov_report
-            ./create_cov_report.sh ${{ matrix.plugin }}
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          verbose: true
-          fail_ci_if_error: true
-          token: ${{ secrets.CODECOV_TOKEN }}
-          directory: ./cov_report/
-          files: ./cov_report/cov-${{ matrix.plugin }}.info

.github/workflows/ci.yml

@@ -8,9 +8,9 @@ on:
       - published
 
 env:
-  VERSION: 2.12.0
+  VERSION: 2.13.0
   UI_VERSION: 2.6.1
-  BRANCH: main
+  BRANCH: v2.13
 
 jobs:
   cross-build:
@@ -19,7 +19,7 @@ jobs:
       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.13
 
     steps:
       - uses: actions/checkout@v4
@@ -62,7 +62,7 @@ jobs:
       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.13
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/manual-unused-plugins.yml

@@ -11,7 +11,7 @@ on:
 jobs:
   build:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
 
     steps:
       - uses: actions/checkout@v4
@@ -33,7 +33,7 @@ jobs:
 
   unused_plugins_test:
     runs-on: ubuntu-24.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.13
     needs: [build]
     strategy:
       matrix:

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.13/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.13/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.13/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.13/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

include/neuron/define.h

@@ -23,7 +23,7 @@
 #include <stdbool.h>
 
 #define NEU_VERSION_MAJOR 2
-#define NEU_VERSION_MINOR 12
+#define NEU_VERSION_MINOR 13
 #define NEU_VERSION_FIX 0
 
 #define NEU_GET_VERSION_MAJOR(V) ((0xffff0000 & V) >> 16)

include/neuron/msg.h

@@ -1625,8 +1625,9 @@ neu_tag_value_to_json_paginate(neu_resp_tag_value_meta_paginate_t *tag_value,
         tag_json->value.val_array_str.p_strs = tag_value->value.value.strs.strs;
         break;
     case NEU_TYPE_CUSTOM:
-        tag_json->t                = NEU_JSON_OBJECT;
-        tag_json->value.val_object = tag_value->value.value.json;
+        tag_json->t = NEU_JSON_OBJECT;
+        tag_json->value.val_object =
+            json_deep_copy(tag_value->value.value.json);
         break;
     default:
         break;

include/neuron/utils/cid.h

@@ -114,6 +114,8 @@ inline static cid_basictype_e decode_basictype(const char *btype)
         ret = VisString64;
     } else if (strcmp(btype, "VisString255") == 0) {
         ret = VisString255;
+    } else if (strcmp(btype, "VisString65") == 0) {
+        ret = Unicode255;
     } else if (strcmp(btype, "Octet64") == 0) {
         ret = Octet64;
     } else if (strcmp(btype, "Struct") == 0) {
@@ -200,6 +202,10 @@ typedef struct {
 
     cid_basictype_e btypes[NEU_TAG_FORMAT_LENGTH]; // for do-[da]
     int             n_btypes;
+    cid_basictype_e btype;
+
+    bool    is_array;
+    uint8_t array_size;
 } cid_fcda_t;
 
 typedef struct {
@@ -298,6 +304,9 @@ typedef struct {
 
     cid_basictype_e btype;
     cid_fc_e        fc;
+
+    bool    is_array;
+    uint8_t array_size;
 } cid_tm_do_da_t;
 
 typedef struct {

persistence/0002_2.3.0_node_cache.sql

@@ -1,36 +0,0 @@
-/**
-* NEURON IIoT System for Industry 4.0
-* Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved.
-*
-* This program is free software; you can redistribute it and/or
-* modify it under the terms of the GNU Lesser General Public
-* License as published by the Free Software Foundation; either
-* version 3 of the License, or (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-* Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public License
-* along with this program; if not, write to the Free Software Foundation,
-* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-**/
-
---- fix primary key ---
-BEGIN;
-
-DROP TABLE IF EXISTS old_node_cache;
-ALTER TABLE node_cache RENAME TO old_node_cache;
-
-CREATE TABLE IF NOT EXISTS node_cache (
-  node_name TEXT PRIMARY KEY,
-  CACHE TEXT NOT NULL,
-  FOREIGN KEY (node_name) REFERENCES nodes (name) ON UPDATE CASCADE ON DELETE CASCADE
-);
-
-INSERT OR REPLACE INTO node_cache SELECT * FROM old_node_cache;
-
-DROP TABLE old_node_cache;
-
-COMMIT;

persistence/0113_2.13.0_certificates.sql

@@ -62,7 +62,7 @@ CREATE TABLE IF NOT EXISTS client_certificates (
     valid_from DATETIME,
     valid_to DATETIME,
     serial_number TEXT,
-    fingerprint TEXT UNIQUE,
+    fingerprint TEXT,
     certificate_data BLOB NOT NULL,
     is_ca INTEGER DEFAULT 0,
     trust_status INTEGER DEFAULT 0,
@@ -75,6 +75,7 @@ CREATE TABLE IF NOT EXISTS client_certificates (
 CREATE INDEX IF NOT EXISTS idx_client_certificates_app_name ON client_certificates(app_name);
 CREATE INDEX IF NOT EXISTS idx_client_certificates_common_name ON client_certificates(common_name);
 CREATE INDEX IF NOT EXISTS idx_client_certificates_fingerprint ON client_certificates(fingerprint);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_client_certificates_app_name_fingerprint ON client_certificates(app_name, fingerprint);
 
 -- Create security policies table for northbound app security management
 CREATE TABLE IF NOT EXISTS security_policies (

plugins/ekuiper/read_write.c

@@ -234,9 +234,22 @@ void recv_data_callback(void *arg)
     if (req->singular) {
         rv = send_write_tag_req(plugin, &req->single, json_str, trace_flag,
                                 trace_id, span_id);
+        if (rv == 0) {
+            plog_notice(plugin, "write tag %s.%s on node %s", req->single.group,
+                        req->single.tag, req->single.node);
+        }
     } else {
         rv = send_write_tags_req(plugin, &req->plural, json_str, trace_flag,
                                  trace_id, span_id);
+        if (rv == 0) {
+            if (req->plural.n_tag == 0) {
+                plog_warn(plugin, "no tags to write on node %s",
+                          req->plural.node);
+            } else {
+                plog_notice(plugin, "write %d tags on node %s",
+                            req->plural.n_tag, req->plural.node);
+            }
+        }
     }
 
     if (0 != rv) {

plugins/modbus/modbus_stack.c

@@ -99,6 +99,8 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
         return -1;
     }
 
+    void *trace_ctx = (void *) ((intptr_t) stack + (intptr_t) stack->read_seq);
+
     switch (code.function) {
     case MODBUS_READ_COIL:
     case MODBUS_READ_INPUT:
@@ -107,7 +109,7 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
         neu_otel_trace_ctx trace = NULL;
         neu_otel_scope_ctx scope = NULL;
         if (neu_otel_data_is_started()) {
-            trace = neu_otel_find_trace((void *) (intptr_t) stack->read_seq);
+            trace = neu_otel_find_trace(trace_ctx);
             if (trace) {
                 char new_span_id[36] = { 0 };
                 neu_otel_new_span_id(new_span_id);
@@ -140,14 +142,14 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
                 stack->value_fn(stack->ctx, code.slave_id,
                                 header.len - sizeof(struct modbus_code) -
                                     sizeof(struct modbus_data),
-                                bytes, 0, (void *) (intptr_t) stack->read_seq);
+                                bytes, 0, trace_ctx);
             } else {
                 bytes = neu_protocol_unpack_buf(buf, data.n_byte);
                 if (bytes == NULL) {
                     return -1;
                 }
                 stack->value_fn(stack->ctx, code.slave_id, data.n_byte, bytes,
-                                0, (void *) (intptr_t) stack->read_seq);
+                                0, trace_ctx);
             }
             break;
         case MODBUS_PROTOCOL_RTU:
@@ -156,7 +158,7 @@ int modbus_stack_recv(modbus_stack_t *stack, uint8_t slave_id,
                 return -1;
             }
             stack->value_fn(stack->ctx, code.slave_id, data.n_byte, bytes, 0,
-                            (void *) (intptr_t) stack->read_seq);
+                            trace_ctx);
             break;
         }
 
@@ -374,8 +376,10 @@ int modbus_stack_read(modbus_stack_t *stack, uint8_t slave_id,
                     neu_otel_trace_ctx trace = NULL;
                     neu_otel_scope_ctx scope = NULL;
                     trace                    = neu_otel_create_trace(
-                        new_trace_id, (void *) (intptr_t) stack->read_seq, 0,
-                        trace_state);
+                        new_trace_id,
+                        (void *) ((intptr_t) stack +
+                                  (intptr_t) stack->read_seq),
+                        0, trace_state);
                     if (trace) {
                         scope = neu_otel_add_span(trace);
                         neu_otel_scope_set_span_name(scope, "driver cmd send");

plugins/restful/normal_handle.c

@@ -835,11 +835,7 @@ void handle_export_db(nng_aio *aio)
         rv             = neu_persister_load_node_setting(node->name,
                                              (const char **) &settings);
         if (rv != 0) {
-            NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_WRITE_FAILURE, {
-                neu_http_response(aio, error_code.error, result_error);
-            });
-            utarray_free(nodes);
-            return;
+            continue;
         }
         rv = settings_write_to_csv("settings.csv", node->name, settings);
         free(settings);
@@ -858,11 +854,7 @@ void handle_export_db(nng_aio *aio)
             UT_array *subscribers = NULL;
             rv = neu_persister_load_subscriptions(node->name, &subscribers);
             if (rv != 0) {
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_WRITE_FAILURE, {
-                    neu_http_response(aio, error_code.error, result_error);
-                });
-                utarray_free(nodes);
-                return;
+                continue;
             }
             rv = subscribes_write_to_csv("subscribes.csv", node->name,
                                          subscribers);
@@ -882,11 +874,7 @@ void handle_export_db(nng_aio *aio)
         UT_array *groups = NULL;
         rv               = neu_persister_load_groups(node->name, &groups);
         if (rv != 0) {
-            NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_WRITE_FAILURE, {
-                neu_http_response(aio, error_code.error, result_error);
-            });
-            utarray_free(nodes);
-            return;
+            continue;
         }
         rv = groups_write_to_csv("groups.csv", node->name, groups);
         if (rv != 0) {
@@ -902,12 +890,7 @@ void handle_export_db(nng_aio *aio)
             UT_array *tags = NULL;
             rv = neu_persister_load_tags(node->name, group->name, &tags);
             if (rv != 0) {
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_WRITE_FAILURE, {
-                    neu_http_response(aio, error_code.error, result_error);
-                });
-                utarray_free(nodes);
-                utarray_free(groups);
-                return;
+                continue;
             }
             rv = tags_write_to_csv("tags.csv", node->name, group->name, tags);
             if (rv != 0) {
@@ -925,14 +908,15 @@ void handle_export_db(nng_aio *aio)
 
     utarray_free(nodes);
 
-    system("rm -rf neuron.tar.gz");
-    system("tar -zcf neuron.tar.gz nodes.csv settings.csv groups.csv tags.csv "
+    system("rm -rf /tmp/neuron.zip");
+    system("zip /tmp/neuron.zip nodes.csv settings.csv groups.csv tags.csv "
            "subscribes.csv");
 
     void * data = NULL;
     size_t len  = 0;
 
-    rv = read_file("neuron.tar.gz", &data, &len);
+    rv = read_file("/tmp/neuron.zip", &data, &len);
+    nlog_info("read_file /tmp/neuron.zip rv=%d, len=%zu", rv, len);
     if (rv != 0) {
         NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_READ_FAILURE, {
             neu_http_response(aio, error_code.error, result_error);
@@ -940,6 +924,6 @@ void handle_export_db(nng_aio *aio)
         return;
     }
     neu_http_response_file(aio, data, len,
-                           "attachment; filename=\"neuron.tar.gz\"");
+                           "attachment; filename=\"neuron.zip\"");
     free(data);
 }

src/adapter/driver/driver.c

@@ -175,7 +175,8 @@ static void write_responses(neu_adapter_t *adapter, void *r,
                             neu_driver_write_responses_t *response,
                             int                           n_response)
 {
-    neu_reqresp_head_t *  req   = (neu_reqresp_head_t *) r;
+    neu_reqresp_head_t *req = (neu_reqresp_head_t *) r;
+    const char *iface = (req->sender[0] != '\0') ? req->sender : "unknown";
     neu_resp_write_tags_t nresp = { 0 };
     req->type                   = NEU_RESP_WRITE_TAGS;
     UT_icd    icd   = { sizeof(neu_resp_write_tags_ele_t), NULL, NULL, NULL };
@@ -190,8 +191,18 @@ static void write_responses(neu_adapter_t *adapter, void *r,
         strcpy(ele.group, resp->group);
         strcpy(ele.tag, resp->name);
         ele.error = resp->error;
+
+        nlog_notice(
+            "driver multi write response detail, driver: %s, interface: "
+            "%s, group: %s, tag: %s, error: %d",
+            adapter->name, iface, resp->group, resp->name, resp->error);
+
         utarray_push_back(array, &ele);
     }
+    nlog_notice(
+        "driver multi write response summary, driver: %s, interface: %s, "
+        "result_count: %d",
+        adapter->name, iface, n_response);
 
     nresp.tags = array;
     adapter->cb_funs.response(adapter, req, &nresp);
@@ -199,8 +210,10 @@ static void write_responses(neu_adapter_t *adapter, void *r,
 
 static void write_response(neu_adapter_t *adapter, void *r, neu_error error)
 {
-    neu_reqresp_head_t *req    = (neu_reqresp_head_t *) r;
-    neu_resp_error_t    nerror = { .error = error };
+    neu_reqresp_head_t *req      = (neu_reqresp_head_t *) r;
+    neu_reqresp_type_e  req_type = req->type;
+    const char *     iface = (req->sender[0] != '\0') ? req->sender : "unknown";
+    neu_resp_error_t nerror = { .error = error };
 
     neu_otel_trace_ctx trace = NULL;
     neu_otel_scope_ctx scope = NULL;
@@ -221,18 +234,55 @@ static void write_response(neu_adapter_t *adapter, void *r, neu_error error)
         }
     }
 
-    if (NEU_REQ_WRITE_TAG == req->type) {
-        neu_req_write_tag_fini((neu_req_write_tag_t *) &req[1]);
+    if (NEU_REQ_WRITE_TAG == req_type) {
+        neu_req_write_tag_t *cmd   = (neu_req_write_tag_t *) &req[1];
+        const char *         group = cmd->group ? cmd->group : "";
+        const char *         tag   = cmd->tag ? cmd->tag : "";
+        nlog_notice("driver single write response, driver: %s, interface: %s, "
+                    "group: %s, tag: %s, %s, error: %d",
+                    adapter->name, iface, group, tag,
+                    neu_value_str(cmd->value.type, cmd->value.value), error);
+        neu_req_write_tag_fini(cmd);
         if (neu_otel_control_is_started() && trace) {
             neu_otel_scope_set_span_name(scope, "driver write tag response");
         }
-    } else if (NEU_REQ_WRITE_TAGS == req->type) {
-        neu_req_write_tags_fini((neu_req_write_tags_t *) &req[1]);
+    } else if (NEU_REQ_WRITE_TAGS == req_type) {
+        neu_req_write_tags_t *cmd   = (neu_req_write_tags_t *) &req[1];
+        const char *          group = cmd->group ? cmd->group : "";
+        nlog_notice("driver multi write response, driver: %s, interface: %s, "
+                    "group: %s, tag_count: %d, error: %d",
+                    adapter->name, iface, group, cmd->n_tag, error);
+        for (int i = 0; i < cmd->n_tag; i++) {
+            const char *tag_name = cmd->tags[i].tag;
+            nlog_notice("driver multi write response tag detail, driver: %s, "
+                        "group: %s, tag: %s, %s",
+                        adapter->name, group, tag_name ? tag_name : "",
+                        neu_value_str(cmd->tags[i].value.type,
+                                      cmd->tags[i].value.value));
+        }
+        neu_req_write_tags_fini(cmd);
         if (neu_otel_control_is_started() && trace) {
             neu_otel_scope_set_span_name(scope, "driver write tags response");
         }
-    } else if (NEU_REQ_WRITE_GTAGS == req->type) {
-        neu_req_write_gtags_fini((neu_req_write_gtags_t *) &req[1]);
+    } else if (NEU_REQ_WRITE_GTAGS == req_type) {
+        neu_req_write_gtags_t *cmd = (neu_req_write_gtags_t *) &req[1];
+        nlog_notice("driver multi write response, driver: %s, interface: %s, "
+                    "group_count: %d, error: %d",
+                    adapter->name, iface, cmd->n_group, error);
+        for (int i = 0; i < cmd->n_group; i++) {
+            const char *group_name =
+                cmd->groups[i].group ? cmd->groups[i].group : "";
+            for (int k = 0; k < cmd->groups[i].n_tag; k++) {
+                const char *tag_name = cmd->groups[i].tags[k].tag;
+                nlog_notice(
+                    "driver multi write response tag detail, driver: %s, "
+                    "group: %s, tag: %s, %s",
+                    adapter->name, group_name, tag_name ? tag_name : "",
+                    neu_value_str(cmd->groups[i].tags[k].value.type,
+                                  cmd->groups[i].tags[k].value.value));
+            }
+        }
+        neu_req_write_gtags_fini(cmd);
         if (neu_otel_control_is_started() && trace) {
             neu_otel_scope_set_span_name(scope, "driver write gtags response");
         }
@@ -1425,6 +1475,23 @@ int neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
         return NEU_ERR_TAG_NOT_EXIST;
     }
 
+    const neu_reqresp_head_t *head = (const neu_reqresp_head_t *) req;
+    const char *              iface =
+        (head && head->sender[0] != '\0') ? head->sender : "unknown";
+
+    nlog_notice("driver multi write request received, driver: %s, group: %s, "
+                "interface: %s, tag_count: %d",
+                driver->adapter.name, cmd->group, iface, cmd->n_tag);
+
+    for (int i = 0; i < cmd->n_tag; i++) {
+        const char *tag_name = cmd->tags[i].tag;
+        nlog_notice(
+            "driver multi write request tag detail, driver: %s, group: %s, "
+            "tag: %s, %s",
+            driver->adapter.name, cmd->group, tag_name ? tag_name : "",
+            neu_value_str(cmd->tags[i].value.type, cmd->tags[i].value.value));
+    }
+
     to_be_write_tag_t wtag = { 0 };
     wtag.single            = false;
     wtag.req               = (void *) req;
@@ -1549,6 +1616,29 @@ int neu_adapter_driver_write_gtags(neu_adapter_driver_t *driver,
         return NEU_ERR_TAG_NOT_EXIST;
     }
 
+    const neu_reqresp_head_t *head = (const neu_reqresp_head_t *) req;
+    const char *              iface =
+        (head && head->sender[0] != '\0') ? head->sender : "unknown";
+
+    nlog_notice(
+        "driver multi write request received, driver: %s, interface: %s, "
+        "group_count: %d, tag_count: %u",
+        driver->adapter.name, iface, cmd->n_group, n_tag);
+
+    for (int i = 0; i < cmd->n_group; i++) {
+        const char *group_name =
+            cmd->groups[i].group ? cmd->groups[i].group : "";
+        for (int k = 0; k < cmd->groups[i].n_tag; k++) {
+            const char *tag_name = cmd->groups[i].tags[k].tag;
+            nlog_notice("driver multi write request tag detail, driver: %s, "
+                        "group: %s, tag: %s, %s",
+                        driver->adapter.name, group_name,
+                        tag_name ? tag_name : "",
+                        neu_value_str(cmd->groups[i].tags[k].value.type,
+                                      cmd->groups[i].tags[k].value.value));
+        }
+    }
+
     to_be_write_tag_t wtag = { 0 };
     wtag.single            = false;
     wtag.req               = (void *) req;
@@ -1614,6 +1704,17 @@ int neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
 
         fix_value(tag, cmd->value.type, &cmd->value);
 
+        const neu_reqresp_head_t *head = (const neu_reqresp_head_t *) req;
+        const char *              iface =
+            (head && head->sender[0] != '\0') ? head->sender : "unknown";
+        const char *group_name = cmd->group ? cmd->group : "";
+        const char *tag_name   = cmd->tag ? cmd->tag : "";
+
+        nlog_notice("driver single write request received, driver: %s, group: "
+                    "%s, tag: %s, interface: %s, %s",
+                    driver->adapter.name, group_name, tag_name, iface,
+                    neu_value_str(cmd->value.type, cmd->value.value));
+
         to_be_write_tag_t wtag = { 0 };
         wtag.single            = true;
         wtag.req               = (void *) req;
@@ -2436,9 +2537,35 @@ static int write_callback(void *usr_data)
             e_time = neu_time_ns();
             neu_tag_free(wtag->tag);
         } else {
-            group->driver->adapter.module->intf_funs->driver.write_tags(
-                group->driver->adapter.plugin, (void *) wtag->req, wtag->tvs);
+            const neu_reqresp_head_t *head =
+                (const neu_reqresp_head_t *) wtag->req;
+            const char *iface =
+                (head && head->sender[0] != '\0') ? head->sender : "unknown";
+
+            size_t tag_count = utarray_len(wtag->tvs);
+            nlog_info("driver multi write request start, driver: %s, group: "
+                      "%s, interface: %s, tag_count: %zu",
+                      group->driver->adapter.name, group->name, iface,
+                      tag_count);
+            utarray_foreach(wtag->tvs, neu_plugin_tag_value_t *, tv)
+            {
+                const char *tag_name =
+                    (tv && tv->tag && tv->tag->name) ? tv->tag->name : "";
+                nlog_info("driver multi write tag detail, driver: %s, group: "
+                          "%s, tag: %s, %s",
+                          group->driver->adapter.name, group->name, tag_name,
+                          neu_value_str(tv->type, tv->value));
+            }
+
+            int ret =
+                group->driver->adapter.module->intf_funs->driver.write_tags(
+                    group->driver->adapter.plugin, (void *) wtag->req,
+                    wtag->tvs);
             e_time = neu_time_ms();
+
+            nlog_info("driver multi write request done, driver: %s, group: %s, "
+                      "interface: %s, ret: %d",
+                      group->driver->adapter.name, group->name, iface, ret);
             utarray_foreach(wtag->tvs, neu_plugin_tag_value_t *, tv)
             {
                 neu_tag_free(tv->tag);
@@ -2690,6 +2817,7 @@ static void read_group(int64_t timestamp, int64_t timeout,
         neu_driver_cache_value_t  value     = { 0 };
 
         strcpy(tag_value.tag, tag->name);
+        tag_value.datatag = *tag;
 
         tag_value.datatag.bias = tag->bias;
 

src/base/msg_internal.h

@@ -83,6 +83,8 @@ extern "C" {
     XX(NEU_RESP_ADD_TAG, neu_resp_add_tag_t)                                   \
     XX(NEU_REQ_ADD_GTAG, neu_req_add_gtag_t)                                   \
     XX(NEU_RESP_ADD_GTAG, neu_resp_add_tag_t)                                  \
+    XX(NEU_REQ_IMPORT_TAGS, neu_req_import_tags_t)                             \
+    XX(NEU_RESP_IMPORT_TAGS, neu_resp_add_tag_t)                               \
     XX(NEU_REQ_DEL_TAG, neu_req_del_tag_t)                                     \
     XX(NEU_REQ_UPDATE_TAG, neu_req_update_tag_t)                               \
     XX(NEU_RESP_UPDATE_TAG, neu_resp_update_tag_t)                             \
@@ -98,6 +100,8 @@ extern "C" {
     XX(NEU_REQRESP_NODE_DELETED, neu_reqresp_node_deleted_t)                   \
     XX(NEU_REQ_ADD_DRIVERS, neu_req_driver_array_t)                            \
     XX(NEU_REQ_UPDATE_LOG_LEVEL, neu_req_update_log_level_t)                   \
+    XX(NEU_REQ_UPDATE_GLOBAL_LOG_LEVEL, neu_req_update_global_log_level_t)     \
+    XX(NEU_REQ_UPDATE_NODE_LOG_LEVEL, neu_req_update_node_log_level_t)         \
     XX(NEU_REQ_PRGFILE_UPLOAD, neu_req_prgfile_upload_t)                       \
     XX(NEU_REQ_PRGFILE_PROCESS, neu_req_prgfile_process_t)                     \
     XX(NEU_RESP_PRGFILE_PROCESS, neu_resp_prgfile_process_t)                   \
@@ -128,6 +132,7 @@ extern "C" {
     XX(NEU_REQ_DEL_TAG_EVENT, neu_req_del_tag_t)                               \
     XX(NEU_REQ_UPDATE_TAG_EVENT, neu_req_update_tag_t)                         \
     XX(NEU_REQ_ADD_GTAG_EVENT, neu_req_add_gtag_t)                             \
+    XX(NEU_REQ_IMPORT_TAGS_EVENT, neu_req_import_tags_t)                       \
     XX(NEU_REQ_ADD_PLUGIN_EVENT, neu_req_add_plugin_t)                         \
     XX(NEU_REQ_DEL_PLUGIN_EVENT, neu_req_del_plugin_t)                         \
     XX(NEU_REQ_SUBSCRIBE_GROUP_EVENT, neu_req_subscribe_t)                     \

src/otel/otel_manager.c

@@ -37,7 +37,7 @@
 
 #define SPAN_ID_LENGTH 16
 #define ID_CHARSET "0123456789abcdef"
-#define TRACE_TIME_OUT (3 * 60 * 1000)
+#define TRACE_TIME_OUT (60 * 1000)
 
 bool   otel_flag               = false;
 char   otel_collector_url[128] = { 0 };
@@ -1072,25 +1072,33 @@ static int otel_timer_cb(void *data)
 
     HASH_ITER(hh, traces_table, el, tmp)
     {
+        bool should_send = false;
+        bool is_timeout  = false;
+
         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);
+            should_send = true;
+            is_timeout  = true;
+            nlog_debug("trace:%s time out, reporting incomplete trace",
+                       (char *) el->ctx->trace_id);
         } 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);
+            should_send = true;
+        }
 
-            uint8_t *data_buf = calloc(1, data_size);
+        if (should_send) {
+            int      data_size = neu_otel_trace_pack_size(el->ctx);
+            uint8_t *data_buf  = calloc(1, data_size);
             neu_otel_trace_pack(el->ctx, data_buf);
             int status = neu_http_post_otel_trace(data_buf, data_size);
             free(data_buf);
-            nlog_debug("send trace:%s status:%d", (char *) el->ctx->trace_id,
+            nlog_debug("send %strace:%s status:%d",
+                       is_timeout ? "timeout " : "", (char *) el->ctx->trace_id,
                        status);
+
             if (status == 200 || status == 400) {
                 HASH_DEL(traces_table, el);
                 neu_otel_free_trace(el->ctx);

src/utils/cid.c

@@ -307,7 +307,8 @@ static int find_da_basic_type(cid_template_t *template, const char *datype_id,
 
 static int find_basic_type(cid_template_t *template, const char *type_id,
                            const char *do_name, const char *da_name,
-                           cid_fc_e fc, cid_basictype_e **btypes)
+                           cid_fc_e fc, cid_basictype_e **btypes,
+                           bool *is_array, uint8_t *array_size)
 {
     *btypes                  = NULL;
     cid_tm_do_type_t *dotype = NULL;
@@ -330,6 +331,8 @@ static int find_basic_type(cid_template_t *template, const char *type_id,
             (*btypes)[index - 1] = dotype->das[i].btype;
             continue;
         }
+        *is_array   = dotype->das[i].is_array;
+        *array_size = dotype->das[i].array_size;
 
         da_basic_type_t da_types[32] = { 0 };
         int n_da_types = find_da_basic_type(template, dotype->das[i].ref_type,
@@ -362,15 +365,28 @@ static void update_dataset(cid_dataset_t *dataset, cid_ldevice_t *ldev,
             find_type_id(ldev, dataset->fcdas[i].prefix,
                          dataset->fcdas[i].lnclass, dataset->fcdas[i].lninst);
         if (type_id != NULL) {
-            cid_basictype_e *bs  = NULL;
-            int              ret = find_basic_type(
-                template, type_id, dataset->fcdas[i].do_name,
-                dataset->fcdas[i].da_name, dataset->fcdas[i].fc, &bs);
+            cid_basictype_e *bs         = NULL;
+            bool             is_array   = false;
+            uint8_t          array_size = 0;
+
+            int ret =
+                find_basic_type(template, type_id, dataset->fcdas[i].do_name,
+                                dataset->fcdas[i].da_name, dataset->fcdas[i].fc,
+                                &bs, &is_array, &array_size);
             if (ret > 0) {
                 if (ret <= 16) {
                     memcpy(dataset->fcdas[i].btypes, bs,
                            ret * sizeof(cid_basictype_e));
-                    dataset->fcdas[i].n_btypes = ret;
+                    dataset->fcdas[i].btype = bs[0];
+                    for (int j = 1; j < ret; j++) {
+                        if ((bs[j] & 0x7f) != 15 && (bs[j] & 0x7f) != 16) {
+                            dataset->fcdas[i].btype = bs[j];
+                        }
+                    }
+
+                    dataset->fcdas[i].n_btypes   = ret;
+                    dataset->fcdas[i].is_array   = is_array;
+                    dataset->fcdas[i].array_size = array_size;
                 } else {
                     nlog_warn(
                         "Too many basic types for %s %s %s %s %s %d %s",
@@ -987,6 +1003,8 @@ static int parse_template(xmlNode *xml_template, cid_template_t *template)
                             (char *) xmlGetProp(da, (const xmlChar *) "name");
                         char *ref_type =
                             (char *) xmlGetProp(da, (const xmlChar *) "type");
+                        char *count =
+                            (char *) xmlGetProp(da, (const xmlChar *) "count");
 
                         if (btype != NULL && fc != NULL && name != NULL) {
                             tm_do->n_das += 1;
@@ -1014,6 +1032,14 @@ static int parse_template(xmlNode *xml_template, cid_template_t *template)
                                 nlog_warn("Unknown fc %s, %d", fc,
                                           (int) da->line);
                             }
+
+                            if (count != NULL) {
+                                tm_da->is_array   = true;
+                                tm_da->array_size = atoi(count);
+                            } else {
+                                tm_da->is_array   = false;
+                                tm_da->array_size = 0;
+                            }
                         }
 
                         if (btype != NULL) {
@@ -1028,6 +1054,9 @@ static int parse_template(xmlNode *xml_template, cid_template_t *template)
                         if (ref_type != NULL) {
                             xmlFree(ref_type);
                         }
+                        if (count != NULL) {
+                            xmlFree(count);
+                        }
                     }
 
                     da = da->next;
@@ -1475,7 +1504,7 @@ static void ln_dataset_to_group(const char *ied_name, const char *ap_name,
                                  fc_to_str(ln->datasets[j].fcdas[k].fc),
                                  ln->datasets[j].fcdas[k].do_name);
                     }
-                    switch (ln->datasets[j].fcdas[k].btypes[0] & 0x7f) {
+                    switch (ln->datasets[j].fcdas[k].btype & 0x7f) {
                     case BOOLEAN:
                         tag->type = NEU_TYPE_BOOL;
                         break;
@@ -1506,9 +1535,15 @@ static void ln_dataset_to_group(const char *ied_name, const char *ap_name,
                     case INT32U:
                         tag->type = NEU_TYPE_UINT32;
                         break;
-                    case FLOAT32:
-                        tag->type = NEU_TYPE_FLOAT;
-                        break;
+                    case FLOAT32: {
+                        if (ln->datasets[j].fcdas[k].is_array) {
+                            tag->type = NEU_TYPE_ARRAY_FLOAT;
+                            break;
+                        } else {
+                            tag->type = NEU_TYPE_FLOAT;
+                            break;
+                        }
+                    }
                     case FLOAT64:
                         tag->type = NEU_TYPE_DOUBLE;
                         break;

src/utils/tpy.c

@@ -211,7 +211,7 @@ void neu_tpy_to_msg(char *driver, tpy_t *tpy, neu_req_add_gtag_t *cmd)
                 to_neu_type(tpy->statics[i].vars[k].type);
             cmd->groups[i].tags[k].attribute =
                 NEU_ATTRIBUTE_READ | NEU_ATTRIBUTE_WRITE;
-            snprintf(address, sizeof(address) - 1, "%ld,%ld",
+            snprintf(address, sizeof(address) - 1, "%" PRIi64 ",%" PRIi64,
                      tpy->statics[i].vars[k].igroup,
                      tpy->statics[i].vars[k].ioffset);
             cmd->groups[i].tags[k].address     = strdup(address);

tests/ft/plugin/test_plugin.py

@@ -244,7 +244,7 @@ class TestPlugin:
         assert 200 == response.status_code
         for plugin in response.json().get("plugins"):
             if plugin['name'] == 'c1':
-                assert plugin['version'] == '2.12.99'
+                assert plugin['version'] == '2.13.99'
 
     @description(given="incorrect configuration", when="update plugin", then="fail")
     def test_10_update_plugin_fail3(self):

tests/plugins/c1/c1_2.c

@@ -63,7 +63,7 @@ static const neu_plugin_intf_funs_t plugin_intf_funs = {
 };
 
 const neu_plugin_module_t neu_plugin_module = {
-    .version         = NEU_VERSION(2, 12, 99),
+    .version         = NEU_VERSION(2, 13, 99),
     .schema          = "c1",
     .module_name     = "c1",
     .module_descr    = "c1 v2",

version

@@ -1 +1 @@
-2.12.0-alpha
+2.13.0