@thinkingai/ae-cli 1.0.30 → 6.0.16-1

package/wiki/te-docs/raw/data-ingestion-guide/server-sdk/c/c-advanced-YAilwk.md

@@ -0,0 +1,210 @@
+---
+code: cpp_server_sdk_advanced
+name: "C++-Advanced"
+wikiToken: YAilwkzevi8lHekvnQ9cqPnrnzh
+parentWikiToken: Zf9Jwl81biGtrbkmBhackD1Fn3c
+updateTime: 1774249326000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=cpp_server_sdk_advanced
+---
+
+## **Sending Events**
+After SDK is initialized, you can track user behaviour data. In general, ordinary events could meet business requirements. You can also use the First/Updatable Event based on your own business requirements.
+### 1.1 **Ordinary Events**
+ You can call `track` to upload events. It is suggested that you set event properties  based on the document about data tracking drafted previously. Procurement of a commodity by a user is taken as the example here:
+```cpp
+TDPropertiesNode event_properties;
+event_properties.SetString("name1", "XZ_debug");
+event_properties.SetString("name2", "logbugs");
+event_properties.SetString("name3", "name3");
+event_properties.SetString("#uuid", "1234567890");
+event_properties.SetNumber("test_number_int", 3);
+event_properties.SetNumber("test_number_double", 3.14);
+event_properties.SetBool("test_bool", true);
+std::string test_string = "test_string";
+event_properties.SetString("test_stl_string1", test_string);
+event_properties.SetDateTime("test_time1", time(nullptr), 0);
+timeb t = {};
+ftime(&t);
+event_properties.SetDateTime("#time", t.time, t.millitm);
+std::vector<std::string> test_list;
+test_list.push_back("item11");
+test_list.push_back("item21");
+event_properties.SetList("test_list1", test_list);
+
+// track event
+te.track("accountId", "distinctId", "eventName", event_properties);
+```
+
+### 1.2 **First Events**
+The First Events refers to events that would only be recorded once for the ID of a certain device or other dimensions.   For example, under certain scenarios, you may want to record the activation event on a certain device.   In this case, you can perform data tracking with the First Event.
+If you want to judge whether an event is the First Event from other dimensions, you can define a first_check_id for the First Event:
+```cpp
+TDPropertiesNode event_properties;
+// first event
+event_properties.SetString("#first_check_id", "first_event");
+te.track_first("accountId", "distinctId", "eventName", event_properties);
+```
+
+<quote-container>
+Note: Since the server has to check whether the event is the First Event, the First Event will be put in storage one hour later by default.
+</quote-container>
+
+### 1.3 ** Updatable Events**
+You can meet the requirements for event data modification under specific scenarios through Updatable Event. The TE would determine the data to be updated according to the event name and event ID.
+```cpp
+// updatable event
+std::string updateEventId = "update_001";
+TDPropertiesNode update_event_properties;
+update_event_properties.SetString("price", "100");
+update_event_properties.SetString("status", "3");
+// the value of "status" is 3, the value of "price" is 100
+te.track_update("accountId", "distinctId", "eventName", updateEventId, update_event_properties);
+
+TDPropertiesNode update_event_new_properties;
+update_event_new_properties.SetString("status", "5");
+// the value of "status" become 5, the value of "price" is still 100
+te.track_update("accountId", "distinctId", "eventName", updateEventId, update_event_new_properties);
+```
+
+### 1.4 **Overwritable Event****s**
+Despite the similarity with Updatable Event, Overwritable Event would cover all historical data with the latest data. Looking from the perspective of effect, such a process is equivalent to the behavior of deleting the previous data while putting the latest data in storage. The TE would determine the data to be updated according to the event name and event ID.
+```cpp
+// overwrite event
+std::string overWriteEventId = "overWrite_001";
+TDPropertiesNode overWrite_event_properties;
+overWrite_event_properties.SetString("money", "99");
+overWrite_event_properties.SetString("code", "10");
+// the value of "code" is 10, the value of "money" is 99
+te.track_overwrite("accountId", "distinctId", "eventName", overWriteEventId, overWrite_event_properties);
+
+TDPropertiesNode overWrite_event_new_properties;
+overWrite_event_new_properties.SetString("money", "66");
+// The "money" has changed to 66，The "code" will be deleted
+te.track_overwrite("accountId", "distinctId", "eventName", overWriteEventId, overWrite_event_new_properties);
+```
+
+## **User Properties**
+User property setting APIs supported by the TE  include: `user_set`, `user_setOnce`, `user_add`, `user_append`, `user_uniqAppend`, `user_unset`, `user_delete`.
+### 2.1 user_set
+You can call `user_set` to set general user properties. The original properties would be replaced if the properties uploaded via the API are used. If  user properties are not set before, user properties will be created. The type of newly-created user properties must conform to that of the uploaded properties. User name setting is taken as the example here:
+```cpp
+TDPropertiesNode userSet_properties;
+userSet_properties.SetString("userName", "A");
+// set user properties. the value of "userName" is "A"
+te.user_set("accountId", "distinctId", userSet_properties);
+
+userSet_properties.SetString("userName", "B");
+// set user properties again，the value of "userName" will change to "B"
+te.user_set("accountId", "distinctId", userSet_properties);
+```
+
+### 2.2 user_setOnce
+If the user property you want to upload only needs to be set once, you can call `user_setOnce` to set the property. If such property had been set before, this message would be ignored. Let's take the setting of the first payment time as an example:
+```cpp
+// user_setOnce
+TDPropertiesNode userSetOnce_properties;
+userSetOnce_properties.SetString("user_one_name", "A");
+// create "user_one_name" property, and the value is "A"
+te.user_setOnce("accountId", "distinctId", userSetOnce_properties);
+
+userSetOnce_properties.SetString("user_one_name", "B");
+// the value of "user_one_name" is still "A"
+te.user_setOnce("accountId", "distinctId", userSetOnce_properties);
+```
+
+### 2.3 user_add
+When you want to upload numeric property for cumulative operation, you can call `user_add`.
+If the property has not been set, it would be given a value of 0 before computing. A negative value could be uploaded, which is equivalent to subtraction operation. Let's take the accumulative payment amount as an example:
+```cpp
+// user_add
+TDPropertiesNode userAdd_properties;
+userAdd_properties.SetNumber("cash", 30);
+// the value of "cash" is 30
+te.user_add("accountId", "distinctId", userAdd_properties);
+
+userAdd_properties.SetNumber("cash", 60);
+// set user properties again，the value of "cash" is 90 now
+te.user_add("accountId", "distinctId", userAdd_properties);
+```
+
+<quote-container>
+The property key is a string, and the value is only allowed to be a numeric value.
+</quote-container>
+
+### 2.4 user_append
+You can call `user_append` to add user properties of array type.
+```cpp
+// user_append
+TDPropertiesNode userAppend_properties;
+std::vector<std::string> userAppendListValue;
+userAppendListValue.push_back("11");
+userAppendListValue.push_back("33");
+userAppend_properties.SetList("arr1", userAppendListValue);
+// the value of "arr1" is ["11", "33"]
+te.user_append("accountId", "distinctId", userAppend_properties);
+
+TDPropertiesNode userAppend_properties_new;
+std::vector<std::string> userAppendListValueNew;
+userAppendListValueNew.push_back("22");
+userAppendListValueNew.push_back("33");
+userAppend_properties_new.SetList("arr1", userAppendListValueNew);
+// the value of "arr1" is ["11", "33", "22", "33"]
+te.user_append("accountId", "distinctId", userAppend_properties_new);
+```
+
+### 2.5 user_uniqAppend
+You can delete duplicated user property by calling `user_uniqAppend` API. If you call `user_append` API, duplicated user property might not be deleted.
+```cpp
+// user_uniqAppend
+TDPropertiesNode userAppend_properties;
+std::vector<std::string> userAppendListValue;
+userAppendListValue.push_back("11");
+userAppendListValue.push_back("33");
+userAppend_properties.SetList("arr1", userAppendListValue);
+// the value of "arr1" is ["11", "33"]
+te.user_uniqAppend("accountId", "distinctId", userAppend_properties);
+
+TDPropertiesNode userAppend_properties_new;
+std::vector<std::string> userAppendListValueNew;
+userAppendListValueNew.push_back("22");
+userAppendListValueNew.push_back("33");
+userAppend_properties_new.SetList("arr1", userAppendListValueNew);
+// the value of "arr1" is ["11", "33", "22"]
+te.user_uniqAppend("accountId", "distinctId", userAppend_properties_new);
+```
+
+### 2.6 user_unset
+When you need to clear the user properties of users, you can call `user_unset` to clear specific properties.  `user_unset` would not create properties that have not been created in the cluster.
+```cpp
+// user_unset
+TDPropertiesNode userUnset_properties;
+userUnset_properties.SetNumber("userName", 0);
+// the value of "userName" will be reset after executed "user_unset"
+te.user_unset("accountId", "distinctId", userUnset_properties);
+```
+
+### 2.7 user_del
+You can call `user_del` to delete a user. After deleting the user, you would no longer be able to inquire about its user property, but could still query the events triggered by the user.
+```cpp
+te.user_del("accountId", "distinctId");
+```
+
+
+## **Other**
+### 3.1 BatchConsumer
+::: warning Notice
+When the amount of data is too large or the network is abnormal, there is a risk of data loss. And it is not recommended to use it in a production environment
+:::
+Batches transmit data to the TE in real time, without the need for a transmission tool.
+```cpp
+TDBatchConsumer batchConsumer("APPID","SERVER_URL", 10);
+TDAnalytics te(batchConsumer, true);
+```
+
+Instruction on parameters:
+- `APPID`: The APPID of your project, which can be found on the project management page of  TE.
+- `SERVER_URL`: 
+  - If you are using a SaaS version, please check the receiver URL on this page
+<image token="UKc5bUYQ5oKVk9xjgW6cS6DHn0c" width="1674" height="1318" align="center"/>
+
+- If you use the private deployment version, you can customize the data tracking URL .

package/wiki/te-docs/raw/data-ingestion-guide/server-sdk/c/c-advanced.md

@@ -0,0 +1,211 @@
+---
+code: c_sdk_advanced
+name: "C-Advanced"
+wikiToken: IvaxwsdOwi8b3Ck84AzcXobtnDb
+parentWikiToken: Er3owqC0UiRR21kCDgZcY4qJn3e
+updateTime: 1774249245000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=c_sdk_advanced
+---
+
+## **Sending  Events**
+After SDK is initialized, you can track user behaviour data. In general, ordinary events could meet business requirements. You can also use the First/Updatable Event based on your own business requirements.
+### 1.1 **Ordinary Events**
+ You can call `td_track` to upload events. It is suggested that you set event properties  based on the document about data tracking drafted previously. Procurement of a commodity by a user is taken as the example here:
+```c
+TDProperties *properties = td_init_properties();
+TD_ASSERT(TD_OK == td_add_string("product_name", "goods_name", strlen("goods_name"), properties));
+
+TD_ASSERT(TD_OK == td_track("account_id", "distinct_id", "product_buy", properties, ta));
+td_free_properties(properties);
+```
+
+### 1.2 **First Events**
+The First Events refers to events that would only be recorded once for the ID of a certain device or other dimensions. For example, under certain scenarios, you may want to record the activation event on a certain device. In this case, you can perform data tracking with the First Event.
+If you want to judge whether an event is the First Event from other dimensions, you can define a first_check_id for the First Event:
+```c
+TD_ASSERT(TD_OK == td_track_first_event("account_id", "distinct_id", "device_activation", "first_id", properties, ta));
+```
+
+<quote-container>
+Note: Since the server has to check whether the event is the First Event, the First Event will be put in storage one hour later by default.
+</quote-container>
+
+### 1.3 ** Updatable Events**
+You can meet the requirements for event data modification under specific scenarios through Updatable Event. The TE would determine the data to be updated according to the event name and event ID.
+```c
+TDProperties *properties = td_init_properties();
+TD_ASSERT(TD_OK == td_add_int("price",100,properties));
+TD_ASSERT(TD_OK == td_add_int("status",3,properties));
+TD_ASSERT(TD_OK == td_track_update("account_id", "distinct_id", "UPDATABLE_EVENT", "event_id",properties, ta));
+td_free_properties(properties);
+
+TDProperties *new_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_add_int("status",5,new_properties));
+TD_ASSERT(TD_OK == td_track_update("account_id", "distinct_id", "UPDATABLE_EVENT", "event_id",new_properties, ta));
+td_free_properties(new_properties);
+```
+
+### 1.4 **Overwritable Event****s**
+Despite the similarity with Updatable Event, Overwritable Event would cover all historical data with the latest data. Looking from the perspective of effect, such a process is equivalent to the behavior of deleting the previous data while putting the latest data in storage. The TE would determine the data to be updated according to the event name and event ID.
+```c
+TDProperties *properties = td_init_properties();
+TD_ASSERT(TD_OK == td_add_int("price",100,properties));
+TD_ASSERT(TD_OK == td_add_int("status",3,properties));
+TD_ASSERT(TD_OK == td_track_overwrite("account_id", "distinct_id", "OVERWRITE_EVENT", "event_id",properties, ta));
+td_free_properties(properties);
+
+TDProperties *new_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_add_int("status",5,new_properties));
+TD_ASSERT(TD_OK == td_track_overwrite("account_id", "distinct_id", "OVERWRITE_EVENT", "event_id",new_properties, ta));
+td_free_properties(new_properties);
+```
+
+## **User Properties**
+User property setting API supported by the TE  include: `td_user_set`, `td_user_setOnce`, `td_user_add`, `td_user_append`, `td_user_uniq_append`, `td_user_unset`, `td_user_delete`.
+### 2.1 td_user_set
+You can call `td_user_set` to set general user properties. The original properties would be replaced if the properties uploaded via the API again. If  user properties are not set before, user properties will be created. The type of newly-created user properties must conform to that of the uploaded properties. User name setting is taken as the example here:
+```c
+TDProperties *user_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_add_string("user_name", "TA", strlen("TA"), user_properties));
+TD_ASSERT(TD_OK == td_user_set("account_id", "distinct_id", user_properties,ta));
+td_free_properties(user_properties);
+
+TDProperties *user_properties2 = td_init_properties();
+TD_ASSERT(TD_OK == td_add_string("user_name", "TE", strlen("TE"), user_properties2));
+TD_ASSERT(TD_OK == td_user_set("account_id", "distinct_id", user_properties2,ta));
+td_free_properties(user_properties2);
+```
+
+### 2.2 td_user_setOnce
+If the user property you want to upload only needs to be set once, you can call `td_user_setOnce` to set the property. If such property had been set before, this message would be ignored. Let's take the setting of the first payment time as an example:
+```c
+TDProperties *user_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_add_string("first_payment_time", "2018-01-01 01:23:45.678", strlen("2018-01-01 01:23:45.678"), user_properties));
+TD_ASSERT(TD_OK == td_user_setOnce("account_id", "distinct_id", user_properties,ta));
+td_free_properties(user_properties);
+
+TDProperties *user_properties2 = td_init_properties();
+TD_ASSERT(TD_OK == td_add_string("first_payment_time", "2018-12-31 01:23:45.678", strlen("2018-12-31 01:23:45.678"), user_properties2));
+TD_ASSERT(TD_OK == td_user_setOnce("account_id", "distinct_id", user_properties2,ta));
+td_free_properties(user_properties2);
+```
+
+### 2.3 td_user_add
+When you want to upload numeric property for cumulative operation, you can call `td_user_add`.
+If the property has not been set, it would be given a value of 0 before computing. A negative value could be uploaded, which is equivalent to subtraction operation. Let's take the accumulative payment amount as an example:
+```c
+TDProperties *user_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_add_int("total_revenue", 30, user_properties));
+TD_ASSERT(TD_OK == td_user_add("account_id", "distinct_id", user_properties, ta));
+td_free_properties(user_properties);
+
+TDProperties *new_user_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_add_int("total_revenue",648 , new_user_properties));
+TD_ASSERT(TD_OK == td_user_add("account_id", "distinct_id", new_user_properties, ta));
+td_free_properties(new_user_properties);
+```
+
+<quote-container>
+The property key is a string, and the value is only allowed to be a numeric value.
+</quote-container>
+
+### 2.4 td_user_append
+You can call `td_user_append` to add user properties of array type.
+```c
+TDProperties *array_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_append_array("user_list", "apple", strlen("apple"), array_properties));
+TD_ASSERT(TD_OK == td_append_array("user_list", "ball", strlen("ball"), array_properties));
+TD_ASSERT(TD_OK == td_user_append("account_id", "distinct_id", array_properties, ta));
+td_free_properties(array_properties);
+
+TDProperties *new_array_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_append_array("user_list", "apple", strlen("apple"), new_array_properties));
+TD_ASSERT(TD_OK == td_append_array("user_list", "cube", strlen("cube"), new_array_properties));
+TD_ASSERT(TD_OK == td_user_append("account_id", "distinct_id", new_array_properties, ta));
+```
+
+### 2.5 td_user_uniq_append
+You can delete duplicated user property by calling `td_user_uniq_append` API. If you call `td_user_uniq_append` API, duplicated user property will be merged.
+```c
+TDProperties *array_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_append_array("user_list", "apple", strlen("apple"), array_properties));
+TD_ASSERT(TD_OK == td_append_array("user_list", "ball", strlen("ball"), array_properties));
+TD_ASSERT(TD_OK == td_user_append("account_id", "distinct_id", array_properties, ta));
+td_free_properties(array_properties);
+
+TDProperties *new_array_properties = td_init_properties();
+TD_ASSERT(TD_OK == td_append_array("user_list", "apple", strlen("apple"), new_array_properties));
+TD_ASSERT(TD_OK == td_append_array("user_list", "cube", strlen("cube"), new_array_properties));
+TD_ASSERT(TD_OK == td_user_uniq_append("account_id","distinct_id", new_array_properties, ta));
+td_free_properties(new_array_properties);
+```
+
+### 2.6 td_user_unset
+When you need to clear the user properties of users, you can call `td_user_unset` to clear specific properties. `td_user_unset` would not create properties that have not been created in the cluster.
+```c
+TD_ASSERT(TD_OK == td_user_unset("account_id", "distinct_id", "test", ta));
+```
+
+### 2.7 td_user_delete
+You can call `td_user_delete` to delete a user. After deleting the user, you would no longer be able to inquire about its user property, but could still query the events triggered by the user.
+```c
+TD_ASSERT(TD_OK == td_user_delete("account_id", "distinct_id", ta));
+```
+
+## **Other**
+### 3.1 BatchConsumer
+::: warning Notice
+When the amount of data is too large or the network is abnormal, there is a risk of data loss. And it is not recommended to use it in a production environment
+:::
+Batches transmit data to the TE in real time, without the need for a transmission tool. 
+e.g. Modify the `CMakeLists.txt` file:
+```bash
+# Product Library: batch consumer
+if(WIN32)
+    add_compile_definitions(USE_WIN)
+    set(CMAKE_C_FLAGS "-std=c99 -pedantic-errors -m64")
+else()
+    add_compile_definitions(USE_POSIX)
+    set(CMAKE_C_FLAGS "-std=c99")
+endif()
+     SET(TE_LIB_NAME thinkingDataBatch)
+     add_library(${TE_LIB_NAME} src/thinkingdata.c src/td_json.c src/td_list.c src/td_util.c src/td_batch_consumer.c src/td_http_client.c)
+if(WIN32)
+      add_compile_definitions(BUILDING_LIBCURL)
+      include_directories(thirdparty/pcre/include thirdparty/curl/include)
+      link_directories(thirdparty/pcre/lib thirdparty/curl/lib)
+      target_link_libraries(${TE_LIB_NAME} pcre_x64 libcurl)
+else()
+      target_link_libraries(${TE_LIB_NAME} curl)
+endif()
+```
+
+```c
+struct TDAnalytics* ta = NULL;
+struct TDConsumer* consumer = NULL;
+
+TDConfig *config = td_init_config();
+
+char* appid = "APPID";
+char* serverURL = "SERVER_URL";
+TD_ASSERT(TD_OK == td_add_string("push_url", serverURL, strlen(serverURL), config));
+TD_ASSERT(TD_OK == td_add_string("appid", appid, strlen(appid), config));
+
+if (TD_OK != td_init_consumer(&consumer, config)) {
+    fprintf(stderr, "Failed to initialize the consumer.");
+    return 1;
+}
+td_free_properties(config);
+if (TD_OK != td_init(consumer, &ta)) {
+    fprintf(stderr, "Failed to initialize the SDK.");
+    return 1;
+}
+```
+
+Instruction on parameters:
+- `APPID`: The APPID of your project, which can be found on the project management page of  TE.
+- `SERVER_URL`: 
+  - If you are using a SaaS version, please check the receiver URL on this page
+<image token="Eg1QbzIeHoAQpOxlbJ6cRMydnYc" width="1674" height="1318" align="center"/>
+
+- If you use the private deployment version, you can customize the data tracking URL .

package/wiki/te-docs/raw/data-ingestion-guide/server-sdk/c/release-notes-PVazwa.md

@@ -0,0 +1,62 @@
+---
+code: cpp_server_sdk_release_note
+name: "Release Notes"
+wikiToken: PVazwaSPXiD22Nk4LlSc6gaHnjy
+parentWikiToken: Zf9Jwl81biGtrbkmBhackD1Fn3c
+updateTime: 1774249332000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=cpp_server_sdk_release_note
+---
+## v2.0.0
+**Date: 2023/11/30**
+**Notes：**
+- Release the official version
+## v2.0.0-beta.1
+**Date: 2023/10/08**
+**Notes：**
+- Enable new API, add 'TD' prefix to class name
+- Not compatible with older SDK. You need to change the class name and namespace manually
+## v1.2.8-beta.2
+**Date: 2023/06/02**
+**Notes：**
+- Handle invalid iterators
+## v1.2.8-beta.1
+**Date: 2023/05/30**
+**Notes：**
+- Improve data writing efficiency
+## v1.2.7
+**Date: 2023/04/07**
+**Notes：**
+- Use thread instead of pthread
+## v1.2.6
+**Date: 2023/03/14**
+**Notes：**
+- Improve stability
+## v1.2.5
+**Date: 2023/02/24**
+**Notes：**
+- Clean up code
+## v1.2.4
+**Date: 2023/02/21**
+**Notes：**
+- Fix platform compatibility problems
+## v1.2.3
+**Date: 2023/02/16**
+**Notes：**
+- Clean up code
+## v1.2.2
+**Date: 2023/02/05**
+**Notes：**
+- Bugfix: uuid
+## v1.2.1
+**Date: 2023/01/11**
+**Notes：**
+- Bugfix:  event report delays because of `bufferSize`
+## v1.2.0 
+**Date: 2022/11/01**
+**Notes：**
+- Supports debug consumer 
+- Supports batch consumer
+## v1.0.0 
+**Date: 2022/05/20**
+**Notes：** 
+- Supports log_consumer

package/wiki/te-docs/raw/data-ingestion-guide/server-sdk/c/release-notes-TADbwY.md

@@ -0,0 +1,50 @@
+---
+code: csharp_sdk_release_note
+name: "Release Notes"
+wikiToken: TADbwYQnKihuXJk2RlJco9tgn9f
+parentWikiToken: V2W3wvcfkiGW3lk9rrDcnosAnqi
+updateTime: 1774249302000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=csharp_sdk_release_note
+---
+
+## v2.0.3
+**Date:** 2025/09/03
+**Notes：**
+- Improve SDK stability
+## v2.0.2
+**Date:** 2025/03/12
+**Notes：**
+- Improve SDK stability
+## v2.0.1
+**Date:** 2024/01/18
+**Notes：**
+- Use thread-level locks
+## v2.0.0
+**Date:** 2023/09/21
+**Notes：**
+- Add new API
+## v1.5.2
+**Date: **2023/04/03
+**Notes：**
+- Support .net and .net statandard 2.0 
+## v1.5.1
+**Date：2022/11/09**
+**Notes：**
+- Support debug model in TE
+## v1.5.0
+**Date：2022/10/28**
+**Notes：**
+- Support log
+- Support multiple projects
+## v1.4.0 
+**Date：2022/05/06**
+**Notes：**
+- Support dynamic properties
+- Support first event reporting 
+- add 'UserUniqAppend' type
+- Support Object And Object Ggroup
+- Upload event with asynchronous
+## v1.3.1
+**Date: 2021/04/22**
+**Notes:**
+- fixbug: LoggerConsumer write file failed

package/wiki/te-docs/raw/data-ingestion-guide/server-sdk/c/release-notes.md

@@ -0,0 +1,69 @@
+---
+code: c_sdk_release_note
+name: "Release Notes"
+wikiToken: QQsgwkqk3iGHBMkYQDqc8ZcBnwf
+parentWikiToken: Er3owqC0UiRR21kCDgZcY4qJn3e
+updateTime: 1774249251000
+sourceUrl: https://docs-v2.thinkingdata.cn/?version=v6.0&lan=en-US&code=c_sdk_release_note
+---
+
+## v2.0.0
+**Date: 2023/11/30**
+**Notes：**
+- Release the official version
+## v2.0.0-beta.1
+**Date: 2023/09/21**
+**Notes：**
+- Using the new api
+## v1.3.7
+**Date: 2023/09/21**
+**Notes：**
+- Release the official version
+## v1.3.7-beta.1
+**Date: 2023/04/23**
+**Notes：**
+- Tidy example program
+- Tidy CMakeList.txt
+- Improve compatibility
+## v1.3.6
+**Date: 2022/06/22**
+**Notes：**
+- Improve stability
+## v1.3.5
+**Date: 2022/05/16**
+**Notes：**
+- Supports debug_consumer 
+- Supports async_batch_consumer 
+- Add API: ta_user_uniq_append()
+## v1.3.4
+**Date: 2022/03/03**
+**Notes：**
+- Supports object group
+## v1.3.3
+**Date: 2022/02/08**
+**Notes：**
+- Fix bug: Possible duplicate name problems because of snprintf
+## v1.3.2
+**Date: 2021/11/23**
+**Notes：**
+- Optimize the snprintf function in windows
+## v1.3.1
+**Date: 2021/11/10**
+**Notes：**
+- Not exit SDK when malloc failed
+## v1.3.0
+**Date: 2021/10/13**
+**Notes：**
+- Add batch consumer 
+## v1.2.3
+**Date: 2021/09/23**
+**Notes：**
+- Fix #first_check_id error 
+## v1.2.2
+**Date: 2021/07/01**
+**Notes：**
+- Adapt to windows environment
+## v1.2.1 
+**Date: 2021/06/09**
+**Notes：**
+- No longer use stdbool library