From 75676cfda8bc57de75165c30705a8c5692553694 Mon Sep 17 00:00:00 2001 From: shripad621git Date: Fri, 8 Sep 2023 15:39:40 +0530 Subject: [PATCH] Insights System Stats --- config/esp32/components/chip/CMakeLists.txt | 4 + config/esp32/components/chip/Kconfig | 6 + examples/lighting-app/esp32/main/main.cpp | 8 + src/tracing/esp32_trace/BUILD.gn | 18 +- .../matter/tracing/insights_sys_stats.cpp | 161 ++++++++++++++++++ .../matter/tracing/insights_sys_stats.h | 75 ++++++++ 6 files changed, 269 insertions(+), 3 deletions(-) create mode 100644 src/tracing/esp32_trace/include/matter/tracing/insights_sys_stats.cpp create mode 100644 src/tracing/esp32_trace/include/matter/tracing/insights_sys_stats.h diff --git a/config/esp32/components/chip/CMakeLists.txt b/config/esp32/components/chip/CMakeLists.txt index 2f8655b81130ee..aa1a60bc0c8ddc 100644 --- a/config/esp32/components/chip/CMakeLists.txt +++ b/config/esp32/components/chip/CMakeLists.txt @@ -264,6 +264,10 @@ if (CONFIG_ENABLE_ESP_INSIGHTS_TRACE) chip_gn_arg_append("matter_enable_esp_insights_trace" "true") endif() +if (CONFIG_ENABLE_ESP_INSIGHTS_SYSTEM_STATS) + chip_gn_arg_append("matter_enable_esp_insights_system_stats" "true") +endif() + if (CONFIG_USE_ESP32_ECDSA_PERIPHERAL) chip_gn_arg_append("chip_use_esp32_ecdsa_peripheral" "true") endif() diff --git a/config/esp32/components/chip/Kconfig b/config/esp32/components/chip/Kconfig index 3c099437ad9813..86786b96cf4326 100644 --- a/config/esp32/components/chip/Kconfig +++ b/config/esp32/components/chip/Kconfig @@ -818,6 +818,12 @@ menu "CHIP Device Layer" Enabling the above option will enable the esp32 specific tracing functionality and report the diagnostic information to the insights cloud. + config ENABLE_ESP_INSIGHTS_SYSTEM_STATS + bool "Enable System Stats for insights" + depends on ESP_INSIGHTS_ENABLED + default n + help + This option enables the system statistics to be sent to the insights cloud. endmenu diff --git a/examples/lighting-app/esp32/main/main.cpp b/examples/lighting-app/esp32/main/main.cpp index 79247258658dd8..60b6b16d1b0d64 100644 --- a/examples/lighting-app/esp32/main/main.cpp +++ b/examples/lighting-app/esp32/main/main.cpp @@ -39,6 +39,10 @@ #include #include +#if CONFIG_ENABLE_ESP_INSIGHTS_SYSTEM_STATS +#include +#endif + #if CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER #include #endif // CONFIG_ENABLE_ESP32_FACTORY_DATA_PROVIDER @@ -113,6 +117,10 @@ static void InitServer(intptr_t context) DeviceCallbacksDelegate::Instance().SetAppDelegate(&sAppDeviceCallbacksDelegate); Esp32AppServer::Init(); // Init ZCL Data Model and CHIP App Server AND Initialize device attestation config + +#if CONFIG_ENABLE_ESP_INSIGHTS_SYSTEM_STATS + chip::System::Stats::InsightsSystemMetrics::GetInstance().RegisterAndEnable(chip::System::Clock::Timeout(5000)); +#endif } extern "C" void app_main() diff --git a/src/tracing/esp32_trace/BUILD.gn b/src/tracing/esp32_trace/BUILD.gn index d7580a3e68ac2a..4d89677fabd18e 100644 --- a/src/tracing/esp32_trace/BUILD.gn +++ b/src/tracing/esp32_trace/BUILD.gn @@ -19,9 +19,21 @@ import("//build_overrides/chip.gni") config("tracing") { include_dirs = [ "include" ] } - +declare_args() +{ + matter_enable_esp_insights_system_stats = false +} source_set("esp32_trace") { - public = [ "include/matter/tracing/macros_impl.h" ] - sources = [ "include/matter/tracing/macros_impl.cpp" ] + public = [ "include/matter/tracing/macros_impl.h", ] + sources = [ "include/matter/tracing/macros_impl.cpp", ] public_configs = [ ":tracing" ] + + if (matter_enable_esp_insights_system_stats) + { + public += ["include/matter/tracing/insights_sys_stats.h",] + sources += ["include/matter/tracing/insights_sys_stats.cpp",] + deps = [ "${chip_root}/src/lib/core", + "${chip_root}/src/system", + "${chip_root}/src/platform"] + } } diff --git a/src/tracing/esp32_trace/include/matter/tracing/insights_sys_stats.cpp b/src/tracing/esp32_trace/include/matter/tracing/insights_sys_stats.cpp new file mode 100644 index 00000000000000..38309dedada3b8 --- /dev/null +++ b/src/tracing/esp32_trace/include/matter/tracing/insights_sys_stats.cpp @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2023 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "insights_sys_stats.h" +#include +#include +#include +#include +#include + +namespace chip { +namespace System { +namespace Stats { + +InsightsSystemMetrics::InsightsSystemMetrics() +{ + mRegistered = false; + mTimeout = System::Clock::Milliseconds32(5000); + for (int i = 0; i < kNumEntries; i++) + { + LabelPointer[i] = (char *) malloc(sizeof(kMaxStringLength)); + } +} + +InsightsSystemMetrics & InsightsSystemMetrics::GetInstance() +{ + static InsightsSystemMetrics instance; + return instance; +} + +InsightsSystemMetrics::~InsightsSystemMetrics() +{ + for (int i = 0; i < chip::System::Stats::kNumEntries; i++) + { + if (LabelPointer[i] != nullptr) + { + free(LabelPointer[i]); + LabelPointer[i] = nullptr; + } + } +} + +static void TimerCallback(Layer * systemLayer, void * context) +{ + auto instance = static_cast(context); + count_t * highwatermarks = GetHighWatermarks(); + for (int i = 0; i < System::Stats::kNumEntries; i++) + { + esp_diag_metrics_add_uint(instance->LabelPointer[i], static_cast(highwatermarks[i])); + } + DeviceLayer::SystemLayer().StartTimer(instance->GetTimeout(), TimerCallback, instance); +} + +CHIP_ERROR InsightsSystemMetrics::UnRegister() +{ + for (int i = 0; i < System::Stats::kNumEntries; i++) + { + if (LabelPointer[i] != nullptr) + { + esp_diag_metrics_unregister(LabelPointer[i]); + } + } + for (int i = 0; i < chip::System::Stats::kNumEntries; i++) + { + if (LabelPointer[i] != nullptr) + { + free(LabelPointer[i]); + LabelPointer[i] = nullptr; + } + } + return CHIP_NO_ERROR; +} + +CHIP_ERROR InsightsSystemMetrics::CancelTimeout(chip::System::Clock::Timeout aTimeout) +{ + if (!mRegistered) + { + return CHIP_ERROR_INCORRECT_STATE; + } + + if (aTimeout == System::Clock::kZero) + { + DeviceLayer::SystemLayer().CancelTimer(TimerCallback, this); + for (int i = 0; i < chip::System::Stats::kNumEntries; i++) + { + if (LabelPointer[i] != nullptr) + { + free(LabelPointer[i]); + LabelPointer[i] = nullptr; + } + } + } + else if (aTimeout != mTimeout) + { + DeviceLayer::SystemLayer().CancelTimer(TimerCallback, this); + mTimeout = aTimeout; + DeviceLayer::SystemLayer().StartTimer(mTimeout, TimerCallback, this); + } + + return CHIP_NO_ERROR; // Return an appropriate value here +} + +CHIP_ERROR InsightsSystemMetrics::RegisterAndEnable(chip::System::Clock::Timeout aTimeout) +{ + if (mRegistered) + { + return CHIP_NO_ERROR; + } + + if (aTimeout == System::Clock::kZero) + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + + const Label * labels = GetStrings(); + for (int i = 0; i < System::Stats::kNumEntries; i++) + { + size_t labelLength = strlen(labels[i]); + if (labelLength > kMaxStringLength) + { + labelLength = kMaxStringLength; + } + + LabelPointer[i] = strndup(labels[i], labelLength - 1); + if (LabelPointer[i] == NULL) + { + UnRegister(); + return CHIP_ERROR_NO_MEMORY; + } + + esp_diag_metrics_register(tag, LabelPointer[i], LabelPointer[i], path, ESP_DIAG_DATA_TYPE_UINT); + } + + SetTimeout(aTimeout); + + CHIP_ERROR err = DeviceLayer::SystemLayer().StartTimer(GetTimeout(), TimerCallback, this); + if (err != CHIP_NO_ERROR) + { + return err; + } + mRegistered = true; + return CHIP_NO_ERROR; +} + +} // namespace Stats +} // namespace System +} // namespace chip diff --git a/src/tracing/esp32_trace/include/matter/tracing/insights_sys_stats.h b/src/tracing/esp32_trace/include/matter/tracing/insights_sys_stats.h new file mode 100644 index 00000000000000..bd00fa0afe6582 --- /dev/null +++ b/src/tracing/esp32_trace/include/matter/tracing/insights_sys_stats.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2023 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +namespace chip { +namespace System { +namespace Stats { + +class InsightsSystemMetrics +{ +public: + static InsightsSystemMetrics & GetInstance(); + + /* + * This api registers the system metrics to the insights and starts the + * timer to enable system stats periodically to the insights. + */ + CHIP_ERROR RegisterAndEnable(chip::System::Clock::Timeout aTimeout); + + /* + * This api unregisters the system stats which are registered + * as metrics to the esp-insights. + */ + CHIP_ERROR UnRegister(); + + /* + * This api cancels the timeout providing the user the flexibility + * to increase or decrease the frequency of sampling the System + * Stats. It cancels the timer if new timeout value is zero. + * If the value of timeout differs from existing value, then + * it cancels the previous timer and starts a new timer. + */ + CHIP_ERROR CancelTimeout(chip::System::Clock::Timeout aTimeout); + + /* + * This api sets the mTimeout value to the specified value. + * if the value of this timer is set to 0, then it cancels + * the timer to fetch system metrics. + */ + void SetTimeout(System::Clock::Timeout aTimeout) { mTimeout = System::Clock::Milliseconds32(aTimeout); } + System::Clock::Timeout GetTimeout() { return mTimeout; } + + // Destructor to deallocate memory + ~InsightsSystemMetrics(); + + char * LabelPointer[chip::System::Stats::kNumEntries]; + +private: + InsightsSystemMetrics(); + static constexpr int kMaxStringLength = 16; + bool mRegistered; + static constexpr char path[] = "sys.mtr"; + static constexpr char tag[] = "MTR"; + System::Clock::Timeout mTimeout; +}; + +} // namespace Stats +} // namespace System +} // namespace chip