diff --git a/plugins/restful/datatag_handle.c b/plugins/restful/datatag_handle.c
index 1cda145b..68068d68 100644
--- a/plugins/restful/datatag_handle.c
+++ b/plugins/restful/datatag_handle.c
@@ -221,7 +221,13 @@ void handle_update_tags(nng_aio *aio)
                     code = NEU_ERR_TAG_NAME_CONFLICT;
                     free(tag);
                 } else {
-                    updated = true;
+                    updated                     = true;
+                    neu_taggrp_config_t *config = neu_system_find_group_config(
+                        plugin, req->node_id, req->group_config_name);
+                    neu_taggrp_config_t *new_config =
+                        neu_taggrp_cfg_clone(config);
+                    neu_system_update_group_config(plugin, req->node_id,
+                                                   new_config);
                 }
             }
 
diff --git a/src/adapter/driver/cache.c b/src/adapter/driver/cache.c
index b4c71036..ec834e32 100644
--- a/src/adapter/driver/cache.c
+++ b/src/adapter/driver/cache.c
@@ -118,9 +118,13 @@ void neu_driver_cache_update(neu_driver_cache_t *cache, const char *key,
         assert(n_byte != 0);
         assert(n_byte <= NEU_VALUE_SIZE);
         elem->n_byte = n_byte;
-        elem->bytes  = calloc(elem->n_byte, 1);
+        elem->bytes  = calloc(elem->n_byte, n_byte);
     } else {
-        assert(n_byte == elem->n_byte);
+        if (n_byte != elem->n_byte) {
+            elem->n_byte = n_byte;
+            elem->bytes  = realloc(elem->bytes, n_byte);
+            memset(elem->bytes, 0, elem->n_byte);
+        }
     }
 
     memcpy(elem->bytes, bytes, elem->n_byte);
diff --git a/src/adapter/driver/driver.c b/src/adapter/driver/driver.c
index 68eb69d6..ae7c9d06 100644
--- a/src/adapter/driver/driver.c
+++ b/src/adapter/driver/driver.c
@@ -467,56 +467,70 @@ static neu_data_val_t *read_group(neu_adapter_driver_t *driver,
             continue;
         }
 
+        int ret = -1;
         switch (tag->type) {
         case NEU_DTYPE_BOOL:
         case NEU_DTYPE_BIT:
         case NEU_DTYPE_INT8:
         case NEU_DTYPE_UINT8:
-            assert(value.n_byte == sizeof(uint8_t));
+            if (value.n_byte == sizeof(uint8_t)) {
+                ret = neu_datatag_pack_add(val, index, tag->type, tag->id,
+                                           (void *) &value.value.u8);
+            }
 
-            neu_datatag_pack_add(val, index, tag->type, tag->id,
-                                 (void *) &value.value.u8);
             break;
         case NEU_DTYPE_INT16:
         case NEU_DTYPE_UINT16: {
-            assert(value.n_byte == sizeof(uint16_t));
-            uint16_t v = value.value.u16;
+            if (value.n_byte == sizeof(uint16_t)) {
+                uint16_t v = value.value.u16;
 
-            neu_datatag_pack_add(val, index, tag->type, tag->id, (void *) &v);
+                ret = neu_datatag_pack_add(val, index, tag->type, tag->id,
+                                           (void *) &v);
+            }
             break;
         }
         case NEU_DTYPE_FLOAT:
         case NEU_DTYPE_INT32:
         case NEU_DTYPE_UINT32: {
-            assert(value.n_byte == sizeof(uint32_t));
-            uint32_t v = value.value.u32;
+            if (value.n_byte == sizeof(uint32_t)) {
+                uint32_t v = value.value.u32;
 
-            neu_datatag_pack_add(val, index, tag->type, tag->id, (void *) &v);
+                ret = neu_datatag_pack_add(val, index, tag->type, tag->id,
+                                           (void *) &v);
+            }
             break;
         }
         case NEU_DTYPE_INT64:
         case NEU_DTYPE_UINT64:
         case NEU_DTYPE_DOUBLE: {
-            assert(value.n_byte == sizeof(uint64_t));
-            uint64_t v = value.value.u64;
+            if (value.n_byte == sizeof(uint64_t)) {
+                uint64_t v = value.value.u64;
 
-            neu_datatag_pack_add(val, index, tag->type, tag->id, (void *) &v);
+                ret = neu_datatag_pack_add(val, index, tag->type, tag->id,
+                                           (void *) &v);
+            }
             break;
         }
         case NEU_DTYPE_CSTR:
             if (neu_datatag_string_is_utf8(value.value.str, value.n_byte)) {
-                neu_datatag_pack_add(val, index, tag->type, tag->id,
-                                     (void *) value.value.str);
+                ret = neu_datatag_pack_add(val, index, tag->type, tag->id,
+                                           (void *) value.value.str);
             } else {
                 char *unknown = "?";
-                neu_datatag_pack_add(val, index, tag->type, tag->id,
-                                     (void *) unknown);
+                ret = neu_datatag_pack_add(val, index, tag->type, tag->id,
+                                           (void *) unknown);
             }
             break;
         default:
             assert(tag->type == 0);
             break;
         }
+
+        if (ret != 0) {
+            error = NEU_ERR_PLUGIN_READ_FAILURE;
+            neu_datatag_pack_add(val, index, NEU_DTYPE_ERRORCODE, *id,
+                                 (void *) &error);
+        }
     }
 
     return val;