From 8e6391202fd619ea0b64403b2c16f36edd1d8d53 Mon Sep 17 00:00:00 2001 From: Lalit Date: Sun, 2 Oct 2022 22:47:54 -0700 Subject: [PATCH 01/13] Add system and process metrics --- .../include/process_metrics_factory.h | 30 ++++++++++++ .../src/linux/process_cpu_time.cc | 47 ++++++++++++++++++ .../src/linux/process_cpu_time.h | 32 ++++++++++++ .../linux/process_metrics_linux_factory.cc | 49 +++++++++++++++++++ .../src/noop/process_metrics_noop_factory.cc | 35 +++++++++++++ .../include/system_metrics_factory.h | 31 ++++++++++++ 6 files changed, 224 insertions(+) create mode 100644 instrumentation/process_metrics/include/process_metrics_factory.h create mode 100644 instrumentation/process_metrics/src/linux/process_cpu_time.cc create mode 100644 instrumentation/process_metrics/src/linux/process_cpu_time.h create mode 100644 instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc create mode 100644 instrumentation/process_metrics/src/noop/process_metrics_noop_factory.cc create mode 100644 instrumentation/system_metrics/include/system_metrics_factory.h diff --git a/instrumentation/process_metrics/include/process_metrics_factory.h b/instrumentation/process_metrics/include/process_metrics_factory.h new file mode 100644 index 000000000..9cf504029 --- /dev/null +++ b/instrumentation/process_metrics/include/process_metrics_factory.h @@ -0,0 +1,30 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +# include "opentelemetry/metrics/observer_result.h" + + +class ProcessMetricsFactory +{ +public: + static void GetProcessCpuTime(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetProcessCpuUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetProcessMemoryUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetProcessMemoryVirtual(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetProcessDiskIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetProcessNetworkIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetProcessThreads(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetProcessOpenFileDescriptors(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetProcessContextSwitches(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + +}; \ No newline at end of file diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.cc b/instrumentation/process_metrics/src/linux/process_cpu_time.cc new file mode 100644 index 000000000..7779b6403 --- /dev/null +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.cc @@ -0,0 +1,47 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#ifdef __linux__ +#include "process_cpu_time.h" +#include + +long ProcessCpuTime::clock_ticks_per_sec_ = sysconf(_SC_CLK_TCK); + +ProcessCpuTime::ProcessCpuTime() +{ + times(&start_time_); + last_time_ = start_time_; +} + +double ProcessCpuTime::TotalElapsedTime() +{ + times(&last_time_); + return ((last_time_.tms_utime + last_time_.tms_stime) - (start_time_.tms_utime + start_time_.tms_stime)) / clock_ticks_per_sec_; +} + +double ProcessCpuTime::TotalElapsedSystemAndUserTime(double &system_time, double &user_time) +{ + times(&last_time_); + user_time = (last_time_.tms_utime - start_time_.tms_utime ) / clock_ticks_per_sec_; + system_time = (last_time_.tms_stime - start_time_.tms_stime ) / clock_ticks_per_sec_; +} + +double ProcessCpuTime::LastElapsedTime() +{ + struct tms current_time_; + times(¤t_time_); + auto elapsed_time = ((current_time_.tms_utime + current_time_.tms_stime) - (last_time_.tms_utime + last_time_.tms_stime)) / clock_ticks_per_sec_; + last_time_ = current_time_; + return elapsed_time; +} + +double ProcessCpuTime::LastElapsedSystemAndUserTime(double &system_time, double &user_time) +{ + struct tms current_time_; + times(¤t_time_); + user_time = (current_time_.tms_utime - last_time_.tms_utime) / clock_ticks_per_sec_; + system_time = (current_time_.tms_stime - last_time_.tms_stime) / clock_ticks_per_sec_; + last_time_ = current_time_; +} + +#endif \ No newline at end of file diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.h b/instrumentation/process_metrics/src/linux/process_cpu_time.h new file mode 100644 index 000000000..2e3c45a4e --- /dev/null +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.h @@ -0,0 +1,32 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#ifdef __linux__ +#include +#include + +class ProcessCpuTime +{ + public: + ProcessCpuTime(); + + // returns cpu time (user + system) from beginning + double TotalElapsedTime(); + + // returns user and system time separately from beginning + void TotalElapsedSystemAndUserTime(double &system_time, double &user_time); + + // returns cpu time (user + system) since last call to Last*Time() + double LastElapsedTime(); + + // returns user and system time separately since last call to Last*Time() + void LastElapsedSystemAndUserTime(double &system_time, double &user_time); + + + private: + static long clock_ticks_per_sec_; + struct tms start_time_; + mutable struct tms last_time_; +}; + +#endif \ No newline at end of file diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc new file mode 100644 index 000000000..7fa210ca5 --- /dev/null +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -0,0 +1,49 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#ifdef __linux__ + +#include "../../include/process_metrics_factory.h" + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + + + void ProcessMetricsFactory::GetProcessCpuTime(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessCpuUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessMemoryUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessMemoryVirtual(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessDiskIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessNetworkIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessThreads(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessOpenFileDescriptors(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessContextSwitches(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + +#endif \ No newline at end of file diff --git a/instrumentation/process_metrics/src/noop/process_metrics_noop_factory.cc b/instrumentation/process_metrics/src/noop/process_metrics_noop_factory.cc new file mode 100644 index 000000000..cffa97ee0 --- /dev/null +++ b/instrumentation/process_metrics/src/noop/process_metrics_noop_factory.cc @@ -0,0 +1,35 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#ifdef NOOP + +#include "../../include/process_metrics_factory.h" + + void ProcessMetricsFactory::GetProcessCpuTime(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessCpuUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessMemoryUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessMemoryVirtual(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessDiskIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessNetworkIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessThreads(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessOpenFileDescriptors(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + + void ProcessMetricsFactory::GetProcessContextSwitches(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + {} + +#endif diff --git a/instrumentation/system_metrics/include/system_metrics_factory.h b/instrumentation/system_metrics/include/system_metrics_factory.h new file mode 100644 index 000000000..073753147 --- /dev/null +++ b/instrumentation/system_metrics/include/system_metrics_factory.h @@ -0,0 +1,31 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +# include "opentelemetry/metrics/observer_result.h" + +class SystemMetricsFactory +{ +public: + static void GetSystemCpuTime(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetSystemCpuUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetSystemMemoryUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetSystemMemoryUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetSystemSwapUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetSystemSwapUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetSystemDiskIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetSystemDiskOperations(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetSystemDiskTime(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + + static void GetSystemDiskMerged(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/); + +}; \ No newline at end of file From 9b66fdc78394d60b7adac178f75a5e7bb54fd45d Mon Sep 17 00:00:00 2001 From: Lalit Date: Mon, 3 Oct 2022 23:12:19 -0700 Subject: [PATCH 02/13] process cpu metrics --- .../src/linux/process_cpu_time.cc | 4 +- .../src/linux/process_cpu_time.h | 1 - .../linux/process_metrics_linux_factory.cc | 48 +++++++++++++++++-- 3 files changed, 47 insertions(+), 6 deletions(-) diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.cc b/instrumentation/process_metrics/src/linux/process_cpu_time.cc index 7779b6403..5c6c8306f 100644 --- a/instrumentation/process_metrics/src/linux/process_cpu_time.cc +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.cc @@ -19,7 +19,7 @@ double ProcessCpuTime::TotalElapsedTime() return ((last_time_.tms_utime + last_time_.tms_stime) - (start_time_.tms_utime + start_time_.tms_stime)) / clock_ticks_per_sec_; } -double ProcessCpuTime::TotalElapsedSystemAndUserTime(double &system_time, double &user_time) +void ProcessCpuTime::TotalElapsedSystemAndUserTime(double &system_time, double &user_time) { times(&last_time_); user_time = (last_time_.tms_utime - start_time_.tms_utime ) / clock_ticks_per_sec_; @@ -35,7 +35,7 @@ double ProcessCpuTime::LastElapsedTime() return elapsed_time; } -double ProcessCpuTime::LastElapsedSystemAndUserTime(double &system_time, double &user_time) +void ProcessCpuTime::LastElapsedSystemAndUserTime(double &system_time, double &user_time) { struct tms current_time_; times(¤t_time_); diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.h b/instrumentation/process_metrics/src/linux/process_cpu_time.h index 2e3c45a4e..ed1b221e6 100644 --- a/instrumentation/process_metrics/src/linux/process_cpu_time.h +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.h @@ -22,7 +22,6 @@ class ProcessCpuTime // returns user and system time separately since last call to Last*Time() void LastElapsedSystemAndUserTime(double &system_time, double &user_time); - private: static long clock_ticks_per_sec_; struct tms start_time_; diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc index 7fa210ca5..a7b196ca9 100644 --- a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -4,6 +4,8 @@ #ifdef __linux__ #include "../../include/process_metrics_factory.h" +#include "opentelemetry/nostd/variant.h" +#include "opentelemetry/sdk/metrics/observer_result.h" #include #include @@ -18,7 +20,33 @@ #include #include - +namespace { + + static void ReadProcessVMandRSS(std::string key, long &mem_size) { + std::string ret; + std::ifstream self_status("/proc/self/status"); + std::string line; + while (std::getline(self_status, line)) + { + std::istringstream is_line(line); + std::string field0; + if(std::getline(is_line, field0, ':')) + { + if (field0 == key) + { + std::string value_str; + if(std::getline(is_line, value_str)) + { + value_str.erase(std::remove_if(value_str.begin(), value_str.end(), + []( auto const& c ) -> bool { return not std::isdigit(c); } ), value_str.end()); + mem_size = std::stol(value_str); + } + } + } + } + mem_size = 0; + } +} void ProcessMetricsFactory::GetProcessCpuTime(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) {} @@ -26,10 +54,24 @@ {} void ProcessMetricsFactory::GetProcessMemoryUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) - {} + { + long rss_size; + ReadProcessVMandRSS("VmRSS", rss_size); + if (rss_size > 0) { + rss_size = rss_size * 1024 ; //bytes + opentelemetry::nostd::get>(observer_result).Observe(rss_size); + } + } void ProcessMetricsFactory::GetProcessMemoryVirtual(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) - {} + { + long vm_size; + ReadProcessVMandRSS("VmSize", vm_size); + if (vm_size > 0) { + vm_size = vm_size * 1024 ; //bytes + opentelemetry::nostd::get>(observer_result).Observe(vm_size); + } + } void ProcessMetricsFactory::GetProcessDiskIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) {} From b0cd209fd4c245ca70d76d6097cb1e574ad1fdd6 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Tue, 4 Oct 2022 18:04:46 -0700 Subject: [PATCH 03/13] fix --- .../linux/process_metrics_linux_factory.cc | 116 +++++++++++++++--- 1 file changed, 98 insertions(+), 18 deletions(-) diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc index a7b196ca9..a94f03914 100644 --- a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -17,15 +17,18 @@ #include #include +#include + #include #include namespace { - static void ReadProcessVMandRSS(std::string key, long &mem_size) { + static void ReadProcSelfFileForKey(std::string file_name, std::string key, long &value) { std::string ret; - std::ifstream self_status("/proc/self/status"); + std::ifstream self_status(file_name, std::ifstream::in); std::string line; + bool found = false; while (std::getline(self_status, line)) { std::istringstream is_line(line); @@ -39,12 +42,51 @@ namespace { { value_str.erase(std::remove_if(value_str.begin(), value_str.end(), []( auto const& c ) -> bool { return not std::isdigit(c); } ), value_str.end()); - mem_size = std::stol(value_str); + value = std::stol(value_str); + found = true; } } } } - mem_size = 0; + value = found ? value : -1; + self_status.close(); + } + + + + static void ReadNetworkIOStats(long &total_read_bytes, long &total_write_bytes) { + std::string ret; + const unsigned initial_headers_idx = 2; // to be ignored + const unsigned read_idx = 1; // column number containing received bytes + const unsigned write_idx = 9; // column number containing sent bytes + const std::string loop_back_interface = "lo:"; + unsigned line_idx = 0; + std::ifstream self_status("/proc/self/net/dev", std::ifstream::in); + std::string line; + while (std::getline(self_status, line)) + { + if (line_idx++ < initial_headers_idx) { + continue; + } + std::stringstream lineStream(line); + std::string value; + size_t count = 0; + while ( lineStream >> value){ + if (count > write_idx){ + break; + } + if (count == 0 && value == loop_back_interface){ + break; + } + if (count == read_idx){ + total_read_bytes += std::stol(value); + } + if (count == write_idx){ + total_write_bytes += std::stol(value); + } + count++; + } + } } } void ProcessMetricsFactory::GetProcessCpuTime(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) @@ -55,35 +97,73 @@ namespace { void ProcessMetricsFactory::GetProcessMemoryUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) { - long rss_size; - ReadProcessVMandRSS("VmRSS", rss_size); - if (rss_size > 0) { - rss_size = rss_size * 1024 ; //bytes - opentelemetry::nostd::get>(observer_result).Observe(rss_size); + long rss_bytes = 0; + ReadProcSelfFileForKey("/proc/self/status", "VmRSS", rss_bytes); + if (rss_bytes >= 0) { + rss_bytes = rss_bytes * 1024 ; //bytes + opentelemetry::nostd::get>(observer_result).Observe(rss_bytes); } } void ProcessMetricsFactory::GetProcessMemoryVirtual(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) { - long vm_size; - ReadProcessVMandRSS("VmSize", vm_size); - if (vm_size > 0) { - vm_size = vm_size * 1024 ; //bytes - opentelemetry::nostd::get>(observer_result).Observe(vm_size); + long vm_bytes = 0; + ReadProcSelfFileForKey("/proc/self/status", "VmSize", vm_bytes); + if (vm_bytes >= 0) { + vm_bytes = vm_bytes * 1024 ; //bytes + opentelemetry::nostd::get>(observer_result).Observe(vm_bytes); } } void ProcessMetricsFactory::GetProcessDiskIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) - {} + { + long read_bytes = 0, write_bytes = 0; + ReadProcSelfFileForKey("/proc/self/io", "read_bytes", read_bytes); + if (read_bytes >= 0 ){ + opentelemetry::nostd::get>(observer_result).Observe(read_bytes, {{"direction", "read"}}); + } + ReadProcSelfFileForKey("/proc/self/io", "write_bytes", write_bytes); + if (write_bytes >= 0 ){ + opentelemetry::nostd::get>(observer_result).Observe(write_bytes, {{"direction", "read"}}); + } + } void ProcessMetricsFactory::GetProcessNetworkIO(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) - {} + { + long read_bytes = 0, write_bytes = 0; + ReadNetworkIOStats(read_bytes, write_bytes); + if (read_bytes > 0 ) { + opentelemetry::nostd::get>(observer_result).Observe(read_bytes, {{"direction", "receive"}}); + } + if (write_bytes > 0){ + opentelemetry::nostd::get>(observer_result).Observe(write_bytes, {{"direction", "transmit"}}); + } + } void ProcessMetricsFactory::GetProcessThreads(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) - {} + { + long threads_count = 0; + ReadProcSelfFileForKey("/proc/self/status", "Threads", threads_count); + if (threads_count > 0){ + opentelemetry::nostd::get>(observer_result).Observe(threads_count); + } + } void ProcessMetricsFactory::GetProcessOpenFileDescriptors(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) - {} + { + std::string path = "/proc/self/fd/"; + auto dir = opendir(path.data()); + size_t count_fds = 0; + while (auto f = readdir(dir)) { + if (!f->d_name || f->d_name[0] == '.') + { + continue ; //Skip everything that starts with a dot + } + count_fds ++; + } + closedir(dir); + opentelemetry::nostd::get>(observer_result).Observe(count_fds); + } void ProcessMetricsFactory::GetProcessContextSwitches(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) {} From 4959a62e214d230cf2e9190c67642f00fa18003d Mon Sep 17 00:00:00 2001 From: Lalit Date: Wed, 5 Oct 2022 17:11:51 -0700 Subject: [PATCH 04/13] fix --- .../process_metrics/src/linux/process_cpu_time.cc | 6 +++--- .../process_metrics/src/linux/process_cpu_time.h | 6 +++--- .../src/linux/process_metrics_linux_factory.cc | 15 +++++++++++---- 3 files changed, 17 insertions(+), 10 deletions(-) diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.cc b/instrumentation/process_metrics/src/linux/process_cpu_time.cc index 5c6c8306f..e154f268d 100644 --- a/instrumentation/process_metrics/src/linux/process_cpu_time.cc +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.cc @@ -13,13 +13,13 @@ ProcessCpuTime::ProcessCpuTime() last_time_ = start_time_; } -double ProcessCpuTime::TotalElapsedTime() +long ProcessCpuTime::TotalElapsedTime() { times(&last_time_); return ((last_time_.tms_utime + last_time_.tms_stime) - (start_time_.tms_utime + start_time_.tms_stime)) / clock_ticks_per_sec_; } -void ProcessCpuTime::TotalElapsedSystemAndUserTime(double &system_time, double &user_time) +void ProcessCpuTime::TotalElapsedSystemAndUserTime(long &system_time, long &user_time) { times(&last_time_); user_time = (last_time_.tms_utime - start_time_.tms_utime ) / clock_ticks_per_sec_; @@ -35,7 +35,7 @@ double ProcessCpuTime::LastElapsedTime() return elapsed_time; } -void ProcessCpuTime::LastElapsedSystemAndUserTime(double &system_time, double &user_time) +void ProcessCpuTime::LastElapsedSystemAndUserTime(long &system_time, long &user_time) { struct tms current_time_; times(¤t_time_); diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.h b/instrumentation/process_metrics/src/linux/process_cpu_time.h index ed1b221e6..ee9fe0a2c 100644 --- a/instrumentation/process_metrics/src/linux/process_cpu_time.h +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.h @@ -11,16 +11,16 @@ class ProcessCpuTime ProcessCpuTime(); // returns cpu time (user + system) from beginning - double TotalElapsedTime(); + long TotalElapsedTime(); // returns user and system time separately from beginning - void TotalElapsedSystemAndUserTime(double &system_time, double &user_time); + void TotalElapsedSystemAndUserTime(long &system_time, long &user_time); // returns cpu time (user + system) since last call to Last*Time() double LastElapsedTime(); // returns user and system time separately since last call to Last*Time() - void LastElapsedSystemAndUserTime(double &system_time, double &user_time); + void LastElapsedSystemAndUserTime(long &system_time, long &user_time); private: static long clock_ticks_per_sec_; diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc index a94f03914..a54e9cee1 100644 --- a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -6,6 +6,7 @@ #include "../../include/process_metrics_factory.h" #include "opentelemetry/nostd/variant.h" #include "opentelemetry/sdk/metrics/observer_result.h" +#include "process_cpu_time.h" #include #include @@ -52,8 +53,6 @@ namespace { self_status.close(); } - - static void ReadNetworkIOStats(long &total_read_bytes, long &total_write_bytes) { std::string ret; const unsigned initial_headers_idx = 2; // to be ignored @@ -90,10 +89,18 @@ namespace { } } void ProcessMetricsFactory::GetProcessCpuTime(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) - {} + { + static ProcessCpuTime cputime; + long system_time = 0, user_time = 0; + cputime.TotalElapsedSystemAndUserTime(system_time, user_time); + opentelemetry::nostd::get>(observer_result).Observe(system_time, {{"state", "system"}}); + opentelemetry::nostd::get>(observer_result).Observe(user_time, {{"state", "user"}}); + } void ProcessMetricsFactory::GetProcessCpuUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) - {} + { + //TODO + } void ProcessMetricsFactory::GetProcessMemoryUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) { From 691b0e470c78ee5649d42009821e3e8e817c5e8b Mon Sep 17 00:00:00 2001 From: Lalit Date: Wed, 5 Oct 2022 21:59:19 -0700 Subject: [PATCH 05/13] more changes --- .../example/metrics_example.cc | 61 ++++++++++++++ .../process_metrics/include/test_lib.h | 18 +++++ .../linux/process_metrics_linux_factory.cc | 27 ++++--- .../process_metrics/src/test_lib.cc | 80 +++++++++++++++++++ 4 files changed, 175 insertions(+), 11 deletions(-) create mode 100644 instrumentation/process_metrics/example/metrics_example.cc create mode 100644 instrumentation/process_metrics/include/test_lib.h create mode 100644 instrumentation/process_metrics/src/test_lib.cc diff --git a/instrumentation/process_metrics/example/metrics_example.cc b/instrumentation/process_metrics/example/metrics_example.cc new file mode 100644 index 000000000..c7813d291 --- /dev/null +++ b/instrumentation/process_metrics/example/metrics_example.cc @@ -0,0 +1,61 @@ +# include +# include +# include "opentelemetry/exporters/ostream/metric_exporter.h" +# include "opentelemetry/metrics/provider.h" +# include "opentelemetry/sdk/metrics/aggregation/default_aggregation.h" +# include "opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader.h" +# include "opentelemetry/sdk/metrics/meter.h" +# include "opentelemetry/sdk/metrics/meter_provider.h" + +#include "../include/test_lib.h" + +namespace metric_sdk = opentelemetry::sdk::metrics; +namespace nostd = opentelemetry::nostd; +namespace common = opentelemetry::common; +namespace exportermetrics = opentelemetry::exporter::metrics; +namespace metrics_api = opentelemetry::metrics; + +namespace +{ + +void initMetrics() +{ + std::unique_ptr exporter{new exportermetrics::OStreamMetricExporter}; + + std::string version{"1.2.0"}; + std::string schema{"https://opentelemetry.io/schemas/1.2.0"}; + + // Initialize and set the global MeterProvider + metric_sdk::PeriodicExportingMetricReaderOptions options; + options.export_interval_millis = std::chrono::milliseconds(1000); + options.export_timeout_millis = std::chrono::milliseconds(500); + std::unique_ptr reader{ + new metric_sdk::PeriodicExportingMetricReader(std::move(exporter), options)}; + auto provider = std::shared_ptr(new metric_sdk::MeterProvider()); + auto p = std::static_pointer_cast(provider); + p->AddMetricReader(std::move(reader)); + + metrics_api::Provider::SetMeterProvider(provider); +} +} // namespace + +int main(int argc, char **argv) +{ + initMetrics(); + std::string example_type; + if (argc >= 2) + { + example_type = argv[1]; + } + if (example_type == "process.cpu.time") + { + TestLib::create_process_cpu_time_observable_counter(); + } + while(true){ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + } + } + + + + diff --git a/instrumentation/process_metrics/include/test_lib.h b/instrumentation/process_metrics/include/test_lib.h new file mode 100644 index 000000000..e7aebb11b --- /dev/null +++ b/instrumentation/process_metrics/include/test_lib.h @@ -0,0 +1,18 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +class TestLib +{ +public: + static void create_process_cpu_time_observable_counter(); + static void create_process_cpu_utilization_observable_gauge(); + static void create_process_memory_usage_observable_gauge(); + static void create_process_memory_virtual_observable_gauge(); + static void create_process_disk_io_observable_counter(); + static void create_process_network_io_observable_counter(); + static void create_process_threads_observable_counter(); + static void create_process_open_files_observable_gauge(); + static void create_process_context_switches_observable_counter(); +}; diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc index a54e9cee1..a0c8cf4f6 100644 --- a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -23,6 +23,8 @@ #include #include +using namespace opentelemetry; + namespace { static void ReadProcSelfFileForKey(std::string file_name, std::string key, long &value) { @@ -93,8 +95,8 @@ namespace { static ProcessCpuTime cputime; long system_time = 0, user_time = 0; cputime.TotalElapsedSystemAndUserTime(system_time, user_time); - opentelemetry::nostd::get>(observer_result).Observe(system_time, {{"state", "system"}}); - opentelemetry::nostd::get>(observer_result).Observe(user_time, {{"state", "user"}}); + nostd::get>>(observer_result)->Observe(system_time, {{"state", "system"}}); + nostd::get>>(observer_result)->Observe(user_time, {{"state", "user"}}); } void ProcessMetricsFactory::GetProcessCpuUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) @@ -108,7 +110,7 @@ namespace { ReadProcSelfFileForKey("/proc/self/status", "VmRSS", rss_bytes); if (rss_bytes >= 0) { rss_bytes = rss_bytes * 1024 ; //bytes - opentelemetry::nostd::get>(observer_result).Observe(rss_bytes); + nostd::get>>(observer_result)->Observe(rss_bytes); } } @@ -118,7 +120,7 @@ namespace { ReadProcSelfFileForKey("/proc/self/status", "VmSize", vm_bytes); if (vm_bytes >= 0) { vm_bytes = vm_bytes * 1024 ; //bytes - opentelemetry::nostd::get>(observer_result).Observe(vm_bytes); + nostd::get>>(observer_result)->Observe(vm_bytes); } } @@ -127,11 +129,11 @@ namespace { long read_bytes = 0, write_bytes = 0; ReadProcSelfFileForKey("/proc/self/io", "read_bytes", read_bytes); if (read_bytes >= 0 ){ - opentelemetry::nostd::get>(observer_result).Observe(read_bytes, {{"direction", "read"}}); + nostd::get>>(observer_result)->Observe(read_bytes, {{"direction", "read"}}); } ReadProcSelfFileForKey("/proc/self/io", "write_bytes", write_bytes); if (write_bytes >= 0 ){ - opentelemetry::nostd::get>(observer_result).Observe(write_bytes, {{"direction", "read"}}); + nostd::get>>(observer_result)->Observe(write_bytes, {{"direction", "write"}}); } } @@ -140,10 +142,10 @@ namespace { long read_bytes = 0, write_bytes = 0; ReadNetworkIOStats(read_bytes, write_bytes); if (read_bytes > 0 ) { - opentelemetry::nostd::get>(observer_result).Observe(read_bytes, {{"direction", "receive"}}); + nostd::get>>(observer_result)->Observe(read_bytes, {{"direction", "receive"}}); } if (write_bytes > 0){ - opentelemetry::nostd::get>(observer_result).Observe(write_bytes, {{"direction", "transmit"}}); + nostd::get>>(observer_result)->Observe(write_bytes, {{"direction", "transmit"}}); } } @@ -152,7 +154,7 @@ namespace { long threads_count = 0; ReadProcSelfFileForKey("/proc/self/status", "Threads", threads_count); if (threads_count > 0){ - opentelemetry::nostd::get>(observer_result).Observe(threads_count); + opentelemetry::nostd::get>>(observer_result)->Observe(threads_count); } } @@ -169,10 +171,13 @@ namespace { count_fds ++; } closedir(dir); - opentelemetry::nostd::get>(observer_result).Observe(count_fds); + opentelemetry::nostd::get>>(observer_result)->Observe(count_fds); } void ProcessMetricsFactory::GetProcessContextSwitches(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) {} -#endif \ No newline at end of file + + + +#endif diff --git a/instrumentation/process_metrics/src/test_lib.cc b/instrumentation/process_metrics/src/test_lib.cc new file mode 100644 index 000000000..6cbb1bf34 --- /dev/null +++ b/instrumentation/process_metrics/src/test_lib.cc @@ -0,0 +1,80 @@ +#include "../include/test_lib.h" +#include "../include/process_metrics_factory.h" +# include "opentelemetry/context/context.h" +# include "opentelemetry/metrics/provider.h" + +namespace nostd = opentelemetry::nostd; +namespace metrics_api = opentelemetry::metrics; + +void TestLib::create_process_cpu_time_observable_counter() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); + auto obserable_counter = meter->CreateLongObservableCounter("process.cpu.time", "des", "unit"); + obserable_counter->AddCallback(ProcessMetricsFactory::GetProcessCpuTime, nullptr); +} + +void TestLib::create_process_cpu_utilization_observable_gauge() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); + auto obserable_gauge = meter->CreateLongObservableGauge("process.cpu.utilization", "des", "unit"); + obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessCpuUtilization, nullptr); +} + +void TestLib::create_process_memory_usage_observable_gauge() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); + auto obserable_gauge = meter->CreateLongObservableGauge("process.memory.usage", "des", "unit"); + obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessMemoryUsage, nullptr); +} + +void TestLib::create_process_memory_virtual_observable_gauge() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); + auto obserable_gauge = meter->CreateLongObservableGauge("process.memory.virtual", "des", "unit"); + obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessMemoryVirtual, nullptr); +} + +void TestLib::create_process_disk_io_observable_counter() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); + auto obserable_gauge = meter->CreateLongObservableGauge("process.disk.io", "des", "unit"); + obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessDiskIO, nullptr); +} + +void TestLib::create_process_network_io_observable_counter() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); + auto obserable_gauge = meter->CreateLongObservableGauge("process.network.io", "des", "unit"); + obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessNetworkIO, nullptr); +} + +void TestLib::create_process_threads_observable_counter() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); + auto obserable_gauge = meter->CreateLongObservableGauge("process.threads", "des", "unit"); + obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessThreads, nullptr); +} + +void TestLib::create_process_open_files_observable_gauge() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); + auto obserable_gauge = meter->CreateLongObservableGauge("process.open.files", "des", "unit"); + obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessOpenFileDescriptors, nullptr); +} + +void TestLib::create_process_context_switches_observable_counter() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); + auto obserable_gauge = meter->CreateLongObservableGauge("process.context.switches", "des", "unit"); + obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessContextSwitches, nullptr); + +} From dbe6084db6745a1fbdf23072b492dea2d01934c7 Mon Sep 17 00:00:00 2001 From: Lalit Date: Thu, 6 Oct 2022 23:26:06 -0700 Subject: [PATCH 06/13] more changes --- .../process_metrics/include/test_lib.h | 20 +++++-- .../process_metrics/src/test_lib.cc | 60 ++++++++++++------- 2 files changed, 53 insertions(+), 27 deletions(-) diff --git a/instrumentation/process_metrics/include/test_lib.h b/instrumentation/process_metrics/include/test_lib.h index e7aebb11b..9758c32d0 100644 --- a/instrumentation/process_metrics/include/test_lib.h +++ b/instrumentation/process_metrics/include/test_lib.h @@ -3,6 +3,8 @@ #pragma once +#include "opentelemetry/nostd/shared_ptr.h" +#include "opentelemetry/metrics/async_instruments.h" class TestLib { public: @@ -10,9 +12,19 @@ class TestLib static void create_process_cpu_utilization_observable_gauge(); static void create_process_memory_usage_observable_gauge(); static void create_process_memory_virtual_observable_gauge(); - static void create_process_disk_io_observable_counter(); - static void create_process_network_io_observable_counter(); - static void create_process_threads_observable_counter(); + static void create_process_disk_io_observable_gauge(); + static void create_process_network_io_observable_gauge(); + static void create_process_threads_observable_gauge(); static void create_process_open_files_observable_gauge(); - static void create_process_context_switches_observable_counter(); + static void create_process_context_switches_observable_gauge(); +private: + static opentelemetry::nostd::shared_ptr cpu_time_obserable_counter_; + static opentelemetry::nostd::shared_ptr cpu_utilization_obserable_gauge_; + static opentelemetry::nostd::shared_ptr memory_usage_obserable_gauge_; + static opentelemetry::nostd::shared_ptr memory_virtual_obserable_gauge_; + static opentelemetry::nostd::shared_ptr disk_io_obserable_gauge_; + static opentelemetry::nostd::shared_ptr network_io_obserable_gauge_; + static opentelemetry::nostd::shared_ptr threads_obserable_gauge_; + static opentelemetry::nostd::shared_ptr open_files_obserable_gauge_; + static opentelemetry::nostd::shared_ptr context_switches_obserable_gauge_; }; diff --git a/instrumentation/process_metrics/src/test_lib.cc b/instrumentation/process_metrics/src/test_lib.cc index 6cbb1bf34..f8f733895 100644 --- a/instrumentation/process_metrics/src/test_lib.cc +++ b/instrumentation/process_metrics/src/test_lib.cc @@ -3,78 +3,92 @@ # include "opentelemetry/context/context.h" # include "opentelemetry/metrics/provider.h" + +#include +#include namespace nostd = opentelemetry::nostd; namespace metrics_api = opentelemetry::metrics; +opentelemetry::nostd::shared_ptr TestLib::cpu_time_obserable_counter_; +opentelemetry::nostd::shared_ptr cpu_utilization_obserable_gauge_; +opentelemetry::nostd::shared_ptr memory_usage_obserable_gauge_; +opentelemetry::nostd::shared_ptr memory_virtual_obserable_gauge_; +opentelemetry::nostd::shared_ptr disk_io_obserable_gauge_; +opentelemetry::nostd::shared_ptr network_io_obserable_gauge_; +opentelemetry::nostd::shared_ptr threads_obserable_gauge_; +opentelemetry::nostd::shared_ptr open_files_obserable_gauge_; +opentelemetry::nostd::shared_ptr context_switches_obserable_gauge_; + void TestLib::create_process_cpu_time_observable_counter() { auto provider = metrics_api::Provider::GetMeterProvider(); - nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - auto obserable_counter = meter->CreateLongObservableCounter("process.cpu.time", "des", "unit"); - obserable_counter->AddCallback(ProcessMetricsFactory::GetProcessCpuTime, nullptr); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0", "schema"); + cpu_time_obserable_counter_ = meter->CreateLongObservableCounter("process.cpu.time", "des", "unit"); + cpu_time_obserable_counter_->AddCallback(ProcessMetricsFactory::GetProcessCpuTime, nullptr); + auto storage = static_cast(cpu_time_obserable_counter_.get())->GetMetricStorage(); } void TestLib::create_process_cpu_utilization_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - auto obserable_gauge = meter->CreateLongObservableGauge("process.cpu.utilization", "des", "unit"); - obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessCpuUtilization, nullptr); + cpu_utilization_obserable_gauge_ = meter->CreateLongObservableGauge("process.cpu.utilization", "des", "unit"); + cpu_utilization_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessCpuUtilization, nullptr); } void TestLib::create_process_memory_usage_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - auto obserable_gauge = meter->CreateLongObservableGauge("process.memory.usage", "des", "unit"); - obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessMemoryUsage, nullptr); + memory_usage_obserable_gauge_ = meter->CreateLongObservableGauge("process.memory.usage", "des", "unit"); + memory_usage_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessMemoryUsage, nullptr); } void TestLib::create_process_memory_virtual_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - auto obserable_gauge = meter->CreateLongObservableGauge("process.memory.virtual", "des", "unit"); - obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessMemoryVirtual, nullptr); + memory_virtual_obserable_gauge_ = meter->CreateLongObservableGauge("process.memory.virtual", "des", "unit"); + memory_virtual_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessMemoryVirtual, nullptr); } -void TestLib::create_process_disk_io_observable_counter() +void TestLib::create_process_disk_io_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - auto obserable_gauge = meter->CreateLongObservableGauge("process.disk.io", "des", "unit"); - obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessDiskIO, nullptr); + disk_io_obserable_gauge_ = meter->CreateLongObservableGauge("process.disk.io", "des", "unit"); + disk_io_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessDiskIO, nullptr); } -void TestLib::create_process_network_io_observable_counter() +void TestLib::create_process_network_io_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - auto obserable_gauge = meter->CreateLongObservableGauge("process.network.io", "des", "unit"); - obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessNetworkIO, nullptr); + network_io_obserable_gauge_ = meter->CreateLongObservableGauge("process.network.io", "des", "unit"); + network_io_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessNetworkIO, nullptr); } -void TestLib::create_process_threads_observable_counter() +void TestLib::create_process_threads_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - auto obserable_gauge = meter->CreateLongObservableGauge("process.threads", "des", "unit"); - obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessThreads, nullptr); + threads_obserable_gauge_ = meter->CreateLongObservableGauge("process.threads", "des", "unit"); + threads_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessThreads, nullptr); } void TestLib::create_process_open_files_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - auto obserable_gauge = meter->CreateLongObservableGauge("process.open.files", "des", "unit"); - obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessOpenFileDescriptors, nullptr); + open_files_obserable_gauge_ = meter->CreateLongObservableGauge("process.open.files", "des", "unit"); + open_files_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessOpenFileDescriptors, nullptr); } -void TestLib::create_process_context_switches_observable_counter() +void TestLib::create_process_context_switches_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - auto obserable_gauge = meter->CreateLongObservableGauge("process.context.switches", "des", "unit"); - obserable_gauge->AddCallback(ProcessMetricsFactory::GetProcessContextSwitches, nullptr); + context_switches_obserable_gauge_ = meter->CreateLongObservableGauge("process.context.switches", "des", "unit"); + context_switches_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessContextSwitches, nullptr); } From 430d6c7bcd1ba80c28a087da1c9e1deb32f3e7be Mon Sep 17 00:00:00 2001 From: Lalit Date: Sun, 9 Oct 2022 22:41:03 -0700 Subject: [PATCH 07/13] fix --- .../process_metrics/CMakeLists.txt | 28 +++++++++++++++++++ .../example/metrics_example.cc | 15 ++++++++++ .../linux/process_metrics_linux_factory.cc | 1 + .../process_metrics/src/test_lib.cc | 16 +++++------ 4 files changed, 52 insertions(+), 8 deletions(-) create mode 100644 instrumentation/process_metrics/CMakeLists.txt diff --git a/instrumentation/process_metrics/CMakeLists.txt b/instrumentation/process_metrics/CMakeLists.txt new file mode 100644 index 000000000..9c45a7ff6 --- /dev/null +++ b/instrumentation/process_metrics/CMakeLists.txt @@ -0,0 +1,28 @@ +cmake_minimum_required(VERSION 3.12) + +project(opentelemetry-fluentd) + +add_definitions(-DHAVE_CONSOLE_LOG) + +find_package(opentelemetry-cpp REQUIRED) +find_package(CURL REQUIRED) + +option(WITH_EXAMPLES "Whether to build example code" ON) + + +include_directories(include) +#if(LINUX) + add_library(opentelemetry_process_metrics src/linux/process_cpu_time.cc src/linux/process_metrics_linux_factory.cc src/test_lib.cc) +#else() +# add_library(opentelemetry_process_metrics src/noop/process_metrics_noop_factory.cc src/test_lib.cc) +#endif() + +#if (WITH_EXAMPLE) + add_executable(metrics_example example/metrics_example.cc) + target_link_libraries(metrics_example opentelemetry_process_metrics opentelemetry-cpp::metrics + opentelemetry-cpp::resources opentelemetry_exporter_ostream_metrics) +#endif() + + + + diff --git a/instrumentation/process_metrics/example/metrics_example.cc b/instrumentation/process_metrics/example/metrics_example.cc index c7813d291..fd66cdb47 100644 --- a/instrumentation/process_metrics/example/metrics_example.cc +++ b/instrumentation/process_metrics/example/metrics_example.cc @@ -20,6 +20,7 @@ namespace void initMetrics() { + std::cout << "\n LALIT->Init metrics\n"; std::unique_ptr exporter{new exportermetrics::OStreamMetricExporter}; std::string version{"1.2.0"}; @@ -35,7 +36,21 @@ void initMetrics() auto p = std::static_pointer_cast(provider); p->AddMetricReader(std::move(reader)); + //process.cpu.time view + std::unique_ptr observable_instrument_selector{ + new metric_sdk::InstrumentSelector(metric_sdk::InstrumentType::kObservableCounter, + "process.cpu.time")}; + std::unique_ptr observable_meter_selector{ + new metric_sdk::MeterSelector("process.cpu.time", "1.2.0", "schema")}; + std::unique_ptr observable_sum_view{ + new metric_sdk::View{"process.metrics", "des", metric_sdk::AggregationType::kSum}}; + p->AddView(std::move(observable_instrument_selector), std::move(observable_meter_selector), + std::move(observable_sum_view)); + + metrics_api::Provider::SetMeterProvider(provider); + std::cout << "\n LALIT->Init metrics done\n"; + } } // namespace diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc index a0c8cf4f6..0308f3755 100644 --- a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -95,6 +95,7 @@ namespace { static ProcessCpuTime cputime; long system_time = 0, user_time = 0; cputime.TotalElapsedSystemAndUserTime(system_time, user_time); + std::cout << " CPU TIME: "<< system_time << " : " << user_time << "\n"; nostd::get>>(observer_result)->Observe(system_time, {{"state", "system"}}); nostd::get>>(observer_result)->Observe(user_time, {{"state", "user"}}); } diff --git a/instrumentation/process_metrics/src/test_lib.cc b/instrumentation/process_metrics/src/test_lib.cc index f8f733895..c832da463 100644 --- a/instrumentation/process_metrics/src/test_lib.cc +++ b/instrumentation/process_metrics/src/test_lib.cc @@ -10,14 +10,14 @@ namespace nostd = opentelemetry::nostd; namespace metrics_api = opentelemetry::metrics; opentelemetry::nostd::shared_ptr TestLib::cpu_time_obserable_counter_; -opentelemetry::nostd::shared_ptr cpu_utilization_obserable_gauge_; -opentelemetry::nostd::shared_ptr memory_usage_obserable_gauge_; -opentelemetry::nostd::shared_ptr memory_virtual_obserable_gauge_; -opentelemetry::nostd::shared_ptr disk_io_obserable_gauge_; -opentelemetry::nostd::shared_ptr network_io_obserable_gauge_; -opentelemetry::nostd::shared_ptr threads_obserable_gauge_; -opentelemetry::nostd::shared_ptr open_files_obserable_gauge_; -opentelemetry::nostd::shared_ptr context_switches_obserable_gauge_; +opentelemetry::nostd::shared_ptr TestLib::cpu_utilization_obserable_gauge_; +opentelemetry::nostd::shared_ptr TestLib::memory_usage_obserable_gauge_; +opentelemetry::nostd::shared_ptr TestLib::memory_virtual_obserable_gauge_; +opentelemetry::nostd::shared_ptr TestLib::disk_io_obserable_gauge_; +opentelemetry::nostd::shared_ptr TestLib::network_io_obserable_gauge_; +opentelemetry::nostd::shared_ptr TestLib::threads_obserable_gauge_; +opentelemetry::nostd::shared_ptr TestLib::open_files_obserable_gauge_; +opentelemetry::nostd::shared_ptr TestLib::context_switches_obserable_gauge_; void TestLib::create_process_cpu_time_observable_counter() { From caeb7eec474333dca56a73fac57a83ee025aa52d Mon Sep 17 00:00:00 2001 From: Lalit Date: Mon, 10 Oct 2022 10:36:22 -0700 Subject: [PATCH 08/13] add cmakelist --- instrumentation/process_metrics/CMakeLists.txt | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/instrumentation/process_metrics/CMakeLists.txt b/instrumentation/process_metrics/CMakeLists.txt index 9c45a7ff6..d042ba25f 100644 --- a/instrumentation/process_metrics/CMakeLists.txt +++ b/instrumentation/process_metrics/CMakeLists.txt @@ -11,18 +11,14 @@ option(WITH_EXAMPLES "Whether to build example code" ON) include_directories(include) -#if(LINUX) +if(LINUX) add_library(opentelemetry_process_metrics src/linux/process_cpu_time.cc src/linux/process_metrics_linux_factory.cc src/test_lib.cc) -#else() -# add_library(opentelemetry_process_metrics src/noop/process_metrics_noop_factory.cc src/test_lib.cc) -#endif() +else() + add_library(opentelemetry_process_metrics src/noop/process_metrics_noop_factory.cc src/test_lib.cc) +endif() -#if (WITH_EXAMPLE) +if (WITH_EXAMPLE) add_executable(metrics_example example/metrics_example.cc) target_link_libraries(metrics_example opentelemetry_process_metrics opentelemetry-cpp::metrics opentelemetry-cpp::resources opentelemetry_exporter_ostream_metrics) -#endif() - - - - +endif() From 4cfb2cbc0afcaded1f100951421b9f787bababfa Mon Sep 17 00:00:00 2001 From: Lalit Date: Mon, 10 Oct 2022 18:42:00 -0700 Subject: [PATCH 09/13] changes --- .../process_metrics/CMakeLists.txt | 8 ++- .../example/metrics_example.cc | 72 +++++++++++++++---- .../linux/process_metrics_linux_factory.cc | 12 +++- 3 files changed, 72 insertions(+), 20 deletions(-) diff --git a/instrumentation/process_metrics/CMakeLists.txt b/instrumentation/process_metrics/CMakeLists.txt index d042ba25f..9c138b4a8 100644 --- a/instrumentation/process_metrics/CMakeLists.txt +++ b/instrumentation/process_metrics/CMakeLists.txt @@ -1,19 +1,21 @@ cmake_minimum_required(VERSION 3.12) -project(opentelemetry-fluentd) +project(opentelemetry-process-metrics) add_definitions(-DHAVE_CONSOLE_LOG) find_package(opentelemetry-cpp REQUIRED) find_package(CURL REQUIRED) -option(WITH_EXAMPLES "Whether to build example code" ON) +option(WITH_EXAMPLE "Whether to build example code" ON) include_directories(include) -if(LINUX) +if(UNIX AND NOT APPLE) + message("LINUX...") add_library(opentelemetry_process_metrics src/linux/process_cpu_time.cc src/linux/process_metrics_linux_factory.cc src/test_lib.cc) else() + message("SOMETHIG ELSE...") add_library(opentelemetry_process_metrics src/noop/process_metrics_noop_factory.cc src/test_lib.cc) endif() diff --git a/instrumentation/process_metrics/example/metrics_example.cc b/instrumentation/process_metrics/example/metrics_example.cc index fd66cdb47..67e631944 100644 --- a/instrumentation/process_metrics/example/metrics_example.cc +++ b/instrumentation/process_metrics/example/metrics_example.cc @@ -1,5 +1,3 @@ -# include -# include # include "opentelemetry/exporters/ostream/metric_exporter.h" # include "opentelemetry/metrics/provider.h" # include "opentelemetry/sdk/metrics/aggregation/default_aggregation.h" @@ -9,6 +7,9 @@ #include "../include/test_lib.h" +# include +# include + namespace metric_sdk = opentelemetry::sdk::metrics; namespace nostd = opentelemetry::nostd; namespace common = opentelemetry::common; @@ -36,6 +37,7 @@ void initMetrics() auto p = std::static_pointer_cast(provider); p->AddMetricReader(std::move(reader)); +#if 0 //process.cpu.time view std::unique_ptr observable_instrument_selector{ new metric_sdk::InstrumentSelector(metric_sdk::InstrumentType::kObservableCounter, @@ -47,7 +49,7 @@ void initMetrics() p->AddView(std::move(observable_instrument_selector), std::move(observable_meter_selector), std::move(observable_sum_view)); - +#endif metrics_api::Provider::SetMeterProvider(provider); std::cout << "\n LALIT->Init metrics done\n"; @@ -56,21 +58,61 @@ void initMetrics() int main(int argc, char **argv) { - initMetrics(); + std::vector args(argv + 1, argv + argc); std::string example_type; - if (argc >= 2) - { - example_type = argv[1]; + if (args.size() == 0) { + std::cout << "Options -- \n" ; + std::cout << "\t --process.cpu.time --process.cpu.utilization --process.memory.usage --process.memory.virtual\n" ; + std::cout << "\t --process.disk.io --process.network.io --process.threads --process.open.files --process.context.switches\n"; + exit(1); } - if (example_type == "process.cpu.time") - { - TestLib::create_process_cpu_time_observable_counter(); + initMetrics(); + for (auto &arg: args) { + if (arg == "--process.cpu.time") { + TestLib::create_process_cpu_time_observable_counter(); + } + else if (arg == "--process.cpu.utilization") + { + TestLib::create_process_cpu_utilization_observable_gauge(); + } + else if (arg == "--process.memory.usage") + { + TestLib::create_process_memory_usage_observable_gauge(); + } + else if (arg == "--process.memory.virtual") + { + TestLib::create_process_memory_virtual_observable_gauge(); + } + else if (arg == "--process.disk.io") + { + TestLib::create_process_disk_io_observable_gauge(); + } + else if (arg == "--process.network.io") + { + TestLib::create_process_network_io_observable_gauge(); + } + else if (arg == "--process.threads") + { + TestLib::create_process_threads_observable_gauge(); + } + else if(arg == "--process.open.files") + { + TestLib::create_process_open_files_observable_gauge(); + } + else if (arg == "--process.context.switches") + { + TestLib::create_process_context_switches_observable_gauge(); + } + else { + std::cout << " Invalid command, exiting.."; + std::cout << "\tOptions -- \n" ; + std::cout << "\t\t --process.cpu.time --process.cpu.utilization --process.memory.usage --process.memory.virtual" ; + std::cout << "\t\t --process.disk.io --process.network.io --process.threads --process.open.files --process.context.switches"; + exit(1); + } } + while(true){ std::this_thread::sleep_for(std::chrono::milliseconds(500)); } - } - - - - +} diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc index 0308f3755..66e4444f4 100644 --- a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -2,7 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 #ifdef __linux__ - +#define HAVE_CONSOLE_LOG #include "../../include/process_metrics_factory.h" #include "opentelemetry/nostd/variant.h" #include "opentelemetry/sdk/metrics/observer_result.h" @@ -95,7 +95,7 @@ namespace { static ProcessCpuTime cputime; long system_time = 0, user_time = 0; cputime.TotalElapsedSystemAndUserTime(system_time, user_time); - std::cout << " CPU TIME: "<< system_time << " : " << user_time << "\n"; + std::cout << "\nCPU TIME: "<< std::dec << system_time << " : " << user_time << "\n"; nostd::get>>(observer_result)->Observe(system_time, {{"state", "system"}}); nostd::get>>(observer_result)->Observe(user_time, {{"state", "user"}}); } @@ -111,6 +111,7 @@ namespace { ReadProcSelfFileForKey("/proc/self/status", "VmRSS", rss_bytes); if (rss_bytes >= 0) { rss_bytes = rss_bytes * 1024 ; //bytes + std::cout << "\n Memory Usage RSS " << std::dec << rss_bytes ; nostd::get>>(observer_result)->Observe(rss_bytes); } } @@ -121,6 +122,7 @@ namespace { ReadProcSelfFileForKey("/proc/self/status", "VmSize", vm_bytes); if (vm_bytes >= 0) { vm_bytes = vm_bytes * 1024 ; //bytes + std::cout << "\n Memory Usage Virtual " << std::dec << vm_bytes; nostd::get>>(observer_result)->Observe(vm_bytes); } } @@ -130,10 +132,12 @@ namespace { long read_bytes = 0, write_bytes = 0; ReadProcSelfFileForKey("/proc/self/io", "read_bytes", read_bytes); if (read_bytes >= 0 ){ + std::cout << "\nDisk IO Read bytes " << read_bytes; nostd::get>>(observer_result)->Observe(read_bytes, {{"direction", "read"}}); } ReadProcSelfFileForKey("/proc/self/io", "write_bytes", write_bytes); if (write_bytes >= 0 ){ + std::cout << "\nDisk IO Write bytes "<< write_bytes; nostd::get>>(observer_result)->Observe(write_bytes, {{"direction", "write"}}); } } @@ -143,9 +147,11 @@ namespace { long read_bytes = 0, write_bytes = 0; ReadNetworkIOStats(read_bytes, write_bytes); if (read_bytes > 0 ) { + std::cout<< "\nNetwork IO Read bytes " << std::dec << read_bytes; nostd::get>>(observer_result)->Observe(read_bytes, {{"direction", "receive"}}); } if (write_bytes > 0){ + std::cout << "\nNetwork IO Write bytes " << std::dec << write_bytes ; nostd::get>>(observer_result)->Observe(write_bytes, {{"direction", "transmit"}}); } } @@ -155,6 +161,7 @@ namespace { long threads_count = 0; ReadProcSelfFileForKey("/proc/self/status", "Threads", threads_count); if (threads_count > 0){ + std::cout << "\nProcess threads " << std::dec << threads_count ; opentelemetry::nostd::get>>(observer_result)->Observe(threads_count); } } @@ -172,6 +179,7 @@ namespace { count_fds ++; } closedir(dir); + std::cout << "\n Open files " << std::dec <>>(observer_result)->Observe(count_fds); } From 873cf17cd65d80aacef11a03b097e88b688920d9 Mon Sep 17 00:00:00 2001 From: Lalit Date: Sun, 23 Oct 2022 12:44:46 -0700 Subject: [PATCH 10/13] Fix --- .../src/linux/process_cpu_time.cc | 21 +++++++++++++++++-- .../src/linux/process_cpu_time.h | 4 ++++ .../linux/process_metrics_linux_factory.cc | 5 +++++ .../process_metrics/src/test_lib.cc | 2 +- 4 files changed, 29 insertions(+), 3 deletions(-) diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.cc b/instrumentation/process_metrics/src/linux/process_cpu_time.cc index e154f268d..12f567481 100644 --- a/instrumentation/process_metrics/src/linux/process_cpu_time.cc +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.cc @@ -4,13 +4,18 @@ #ifdef __linux__ #include "process_cpu_time.h" #include +#include +#include + long ProcessCpuTime::clock_ticks_per_sec_ = sysconf(_SC_CLK_TCK); ProcessCpuTime::ProcessCpuTime() +: number_of_cpus_{std::thread::hardware_concurrency()} { times(&start_time_); last_time_ = start_time_; + } long ProcessCpuTime::TotalElapsedTime() @@ -22,6 +27,7 @@ long ProcessCpuTime::TotalElapsedTime() void ProcessCpuTime::TotalElapsedSystemAndUserTime(long &system_time, long &user_time) { times(&last_time_); + std::cout << " ===> " << last_time_.tms_utime << " == " << last_time_.tms_stime << " == " << clock_ticks_per_sec_ << "\n"; user_time = (last_time_.tms_utime - start_time_.tms_utime ) / clock_ticks_per_sec_; system_time = (last_time_.tms_stime - start_time_.tms_stime ) / clock_ticks_per_sec_; } @@ -30,15 +36,26 @@ double ProcessCpuTime::LastElapsedTime() { struct tms current_time_; times(¤t_time_); - auto elapsed_time = ((current_time_.tms_utime + current_time_.tms_stime) - (last_time_.tms_utime + last_time_.tms_stime)) / clock_ticks_per_sec_; + auto elapsed_total_time = ((current_time_.tms_utime + current_time_.tms_stime) - (last_time_.tms_utime + last_time_.tms_stime)) / clock_ticks_per_sec_; + last_time_ = current_time_; + return elapsed_total_time; +} + +double ProcessCpuTime::CpuUtilization() +{ + struct tms current_time_; + times(¤t_time_); + auto elapsed_total_time = ((current_time_.tms_utime + current_time_.tms_stime) - (last_time_.tms_utime + last_time_.tms_stime)) / clock_ticks_per_sec_; + auto elapsed_cpu_time = ( current_time_.tms_stime - last_time_.tms_stime) / clock_ticks_per_sec_; last_time_ = current_time_; - return elapsed_time; + return elapsed_cpu_time/(elapsed_total_time * number_of_cpus_); } void ProcessCpuTime::LastElapsedSystemAndUserTime(long &system_time, long &user_time) { struct tms current_time_; times(¤t_time_); + std::cout << " ===> " << current_time_.tms_utime << " == " << current_time_.tms_stime << " == " << clock_ticks_per_sec_ << "\n"; user_time = (current_time_.tms_utime - last_time_.tms_utime) / clock_ticks_per_sec_; system_time = (current_time_.tms_stime - last_time_.tms_stime) / clock_ticks_per_sec_; last_time_ = current_time_; diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.h b/instrumentation/process_metrics/src/linux/process_cpu_time.h index ee9fe0a2c..58da33c41 100644 --- a/instrumentation/process_metrics/src/linux/process_cpu_time.h +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.h @@ -19,6 +19,9 @@ class ProcessCpuTime // returns cpu time (user + system) since last call to Last*Time() double LastElapsedTime(); + // returns cpu utilization + double CpuUtilization(); + // returns user and system time separately since last call to Last*Time() void LastElapsedSystemAndUserTime(long &system_time, long &user_time); @@ -26,6 +29,7 @@ class ProcessCpuTime static long clock_ticks_per_sec_; struct tms start_time_; mutable struct tms last_time_; + const unsigned int number_of_cpus_; }; #endif \ No newline at end of file diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc index 66e4444f4..45e09e0f1 100644 --- a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -102,6 +102,11 @@ namespace { void ProcessMetricsFactory::GetProcessCpuUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) { + static ProcessCpuTime cputime; + double cpu_utilization = cputime.CpuUtilization(); + std::cout << "\n CPU TIME: " << cpu_utilization; + nostd::get>>(observer_result)->Observe(cpu_utilization, {{"state", "system"}}); + //TODO } diff --git a/instrumentation/process_metrics/src/test_lib.cc b/instrumentation/process_metrics/src/test_lib.cc index c832da463..aa8dbdb05 100644 --- a/instrumentation/process_metrics/src/test_lib.cc +++ b/instrumentation/process_metrics/src/test_lib.cc @@ -32,7 +32,7 @@ void TestLib::create_process_cpu_utilization_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - cpu_utilization_obserable_gauge_ = meter->CreateLongObservableGauge("process.cpu.utilization", "des", "unit"); + cpu_utilization_obserable_gauge_ = meter->CreateDoubleObservableGauge("process.cpu.utilization", "des", "unit"); cpu_utilization_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessCpuUtilization, nullptr); } From f398f848cef5159104d11cd49942a138cb443351 Mon Sep 17 00:00:00 2001 From: Lalit Date: Sun, 23 Oct 2022 17:51:00 -0700 Subject: [PATCH 11/13] fix --- .../src/linux/process_cpu_time.cc | 54 +++++++------------ .../src/linux/process_cpu_time.h | 10 ++-- .../linux/process_metrics_linux_factory.cc | 30 +++++------ 3 files changed, 35 insertions(+), 59 deletions(-) diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.cc b/instrumentation/process_metrics/src/linux/process_cpu_time.cc index 12f567481..f534e9b88 100644 --- a/instrumentation/process_metrics/src/linux/process_cpu_time.cc +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.cc @@ -6,59 +6,45 @@ #include #include #include +#include long ProcessCpuTime::clock_ticks_per_sec_ = sysconf(_SC_CLK_TCK); ProcessCpuTime::ProcessCpuTime() -: number_of_cpus_{std::thread::hardware_concurrency()} +: number_of_cpus_{std::thread::hardware_concurrency()}, last_clock_time_{std::chrono::high_resolution_clock::now()} { times(&start_time_); - last_time_ = start_time_; - + last_cpu_time_ = start_time_; } long ProcessCpuTime::TotalElapsedTime() { - times(&last_time_); - return ((last_time_.tms_utime + last_time_.tms_stime) - (start_time_.tms_utime + start_time_.tms_stime)) / clock_ticks_per_sec_; -} - -void ProcessCpuTime::TotalElapsedSystemAndUserTime(long &system_time, long &user_time) -{ - times(&last_time_); - std::cout << " ===> " << last_time_.tms_utime << " == " << last_time_.tms_stime << " == " << clock_ticks_per_sec_ << "\n"; - user_time = (last_time_.tms_utime - start_time_.tms_utime ) / clock_ticks_per_sec_; - system_time = (last_time_.tms_stime - start_time_.tms_stime ) / clock_ticks_per_sec_; + times(&last_cpu_time_); + return ((last_cpu_time_.tms_utime + last_cpu_time_.tms_stime) - (start_time_.tms_utime + start_time_.tms_stime)) / clock_ticks_per_sec_; } double ProcessCpuTime::LastElapsedTime() { - struct tms current_time_; - times(¤t_time_); - auto elapsed_total_time = ((current_time_.tms_utime + current_time_.tms_stime) - (last_time_.tms_utime + last_time_.tms_stime)) / clock_ticks_per_sec_; - last_time_ = current_time_; - return elapsed_total_time; + struct tms current_cpu_time; + times(¤t_cpu_time); + auto elapsed_cpu_time = ((current_cpu_time.tms_utime + current_cpu_time.tms_stime) - (last_cpu_time_.tms_utime + last_cpu_time_.tms_stime)) / clock_ticks_per_sec_; + last_cpu_time_ = current_cpu_time; + return elapsed_cpu_time; } double ProcessCpuTime::CpuUtilization() { - struct tms current_time_; - times(¤t_time_); - auto elapsed_total_time = ((current_time_.tms_utime + current_time_.tms_stime) - (last_time_.tms_utime + last_time_.tms_stime)) / clock_ticks_per_sec_; - auto elapsed_cpu_time = ( current_time_.tms_stime - last_time_.tms_stime) / clock_ticks_per_sec_; - last_time_ = current_time_; - return elapsed_cpu_time/(elapsed_total_time * number_of_cpus_); -} - -void ProcessCpuTime::LastElapsedSystemAndUserTime(long &system_time, long &user_time) -{ - struct tms current_time_; - times(¤t_time_); - std::cout << " ===> " << current_time_.tms_utime << " == " << current_time_.tms_stime << " == " << clock_ticks_per_sec_ << "\n"; - user_time = (current_time_.tms_utime - last_time_.tms_utime) / clock_ticks_per_sec_; - system_time = (current_time_.tms_stime - last_time_.tms_stime) / clock_ticks_per_sec_; - last_time_ = current_time_; + struct tms current_cpu_time; + times(¤t_cpu_time); + auto current_clock_time = std::chrono::high_resolution_clock::now(); + auto elapsed_cpu_time = ((current_cpu_time.tms_utime + current_cpu_time.tms_stime) - (last_cpu_time_.tms_utime + last_cpu_time_.tms_stime)) / clock_ticks_per_sec_; + auto elapsed_clock_time = std::chrono::duration_cast(current_clock_time - last_clock_time_); + last_clock_time_ = current_clock_time; + double cpu_utlization = 0; + if (elapsed_clock_time.count() > 0) + cpu_utlization = elapsed_cpu_time/(elapsed_clock_time.count() * number_of_cpus_); + return cpu_utlization; } #endif \ No newline at end of file diff --git a/instrumentation/process_metrics/src/linux/process_cpu_time.h b/instrumentation/process_metrics/src/linux/process_cpu_time.h index 58da33c41..79dbc3767 100644 --- a/instrumentation/process_metrics/src/linux/process_cpu_time.h +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.h @@ -3,6 +3,7 @@ #ifdef __linux__ #include +#include #include class ProcessCpuTime @@ -13,23 +14,18 @@ class ProcessCpuTime // returns cpu time (user + system) from beginning long TotalElapsedTime(); - // returns user and system time separately from beginning - void TotalElapsedSystemAndUserTime(long &system_time, long &user_time); - // returns cpu time (user + system) since last call to Last*Time() double LastElapsedTime(); // returns cpu utilization double CpuUtilization(); - // returns user and system time separately since last call to Last*Time() - void LastElapsedSystemAndUserTime(long &system_time, long &user_time); - private: static long clock_ticks_per_sec_; struct tms start_time_; - mutable struct tms last_time_; + mutable struct tms last_cpu_time_; const unsigned int number_of_cpus_; + std::chrono::time_point last_clock_time_; }; #endif \ No newline at end of file diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc index 45e09e0f1..c6b6567e8 100644 --- a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -22,6 +22,7 @@ #include #include +#include using namespace opentelemetry; @@ -93,21 +94,15 @@ namespace { void ProcessMetricsFactory::GetProcessCpuTime(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) { static ProcessCpuTime cputime; - long system_time = 0, user_time = 0; - cputime.TotalElapsedSystemAndUserTime(system_time, user_time); - std::cout << "\nCPU TIME: "<< std::dec << system_time << " : " << user_time << "\n"; - nostd::get>>(observer_result)->Observe(system_time, {{"state", "system"}}); - nostd::get>>(observer_result)->Observe(user_time, {{"state", "user"}}); + double cpu_time =cputime.TotalElapsedTime(); + nostd::get>>(observer_result)->Observe(cpu_time); } void ProcessMetricsFactory::GetProcessCpuUtilization(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) { static ProcessCpuTime cputime; double cpu_utilization = cputime.CpuUtilization(); - std::cout << "\n CPU TIME: " << cpu_utilization; - nostd::get>>(observer_result)->Observe(cpu_utilization, {{"state", "system"}}); - - //TODO + nostd::get>>(observer_result)->Observe(cpu_utilization); } void ProcessMetricsFactory::GetProcessMemoryUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) @@ -116,7 +111,6 @@ namespace { ReadProcSelfFileForKey("/proc/self/status", "VmRSS", rss_bytes); if (rss_bytes >= 0) { rss_bytes = rss_bytes * 1024 ; //bytes - std::cout << "\n Memory Usage RSS " << std::dec << rss_bytes ; nostd::get>>(observer_result)->Observe(rss_bytes); } } @@ -127,7 +121,6 @@ namespace { ReadProcSelfFileForKey("/proc/self/status", "VmSize", vm_bytes); if (vm_bytes >= 0) { vm_bytes = vm_bytes * 1024 ; //bytes - std::cout << "\n Memory Usage Virtual " << std::dec << vm_bytes; nostd::get>>(observer_result)->Observe(vm_bytes); } } @@ -137,12 +130,10 @@ namespace { long read_bytes = 0, write_bytes = 0; ReadProcSelfFileForKey("/proc/self/io", "read_bytes", read_bytes); if (read_bytes >= 0 ){ - std::cout << "\nDisk IO Read bytes " << read_bytes; nostd::get>>(observer_result)->Observe(read_bytes, {{"direction", "read"}}); } ReadProcSelfFileForKey("/proc/self/io", "write_bytes", write_bytes); if (write_bytes >= 0 ){ - std::cout << "\nDisk IO Write bytes "<< write_bytes; nostd::get>>(observer_result)->Observe(write_bytes, {{"direction", "write"}}); } } @@ -152,11 +143,9 @@ namespace { long read_bytes = 0, write_bytes = 0; ReadNetworkIOStats(read_bytes, write_bytes); if (read_bytes > 0 ) { - std::cout<< "\nNetwork IO Read bytes " << std::dec << read_bytes; nostd::get>>(observer_result)->Observe(read_bytes, {{"direction", "receive"}}); } if (write_bytes > 0){ - std::cout << "\nNetwork IO Write bytes " << std::dec << write_bytes ; nostd::get>>(observer_result)->Observe(write_bytes, {{"direction", "transmit"}}); } } @@ -166,7 +155,6 @@ namespace { long threads_count = 0; ReadProcSelfFileForKey("/proc/self/status", "Threads", threads_count); if (threads_count > 0){ - std::cout << "\nProcess threads " << std::dec << threads_count ; opentelemetry::nostd::get>>(observer_result)->Observe(threads_count); } } @@ -184,12 +172,18 @@ namespace { count_fds ++; } closedir(dir); - std::cout << "\n Open files " << std::dec <>>(observer_result)->Observe(count_fds); } void ProcessMetricsFactory::GetProcessContextSwitches(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) - {} + { + long voluntary_ctxt_switches = 0; + long nonvoluntary_ctxt_switches = 0; + ReadProcSelfFileForKey("/proc/self/status", "voluntary_ctxt_switches", voluntary_ctxt_switches); + ReadProcSelfFileForKey("/proc/self/status", "nonvoluntary_ctxt_switches", nonvoluntary_ctxt_switches); + auto total_ctxt_switches = voluntary_ctxt_switches + nonvoluntary_ctxt_switches; + opentelemetry::nostd::get>>(observer_result)->Observe(total_ctxt_switches); + } From b2a4ea403179b39428c5aae6c60a6287fd13f245 Mon Sep 17 00:00:00 2001 From: Lalit Date: Sun, 23 Oct 2022 17:54:06 -0700 Subject: [PATCH 12/13] fix --- .../process_metrics/src/linux/process_metrics_linux_factory.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc index c6b6567e8..2a2b21dbb 100644 --- a/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -182,7 +182,8 @@ namespace { ReadProcSelfFileForKey("/proc/self/status", "voluntary_ctxt_switches", voluntary_ctxt_switches); ReadProcSelfFileForKey("/proc/self/status", "nonvoluntary_ctxt_switches", nonvoluntary_ctxt_switches); auto total_ctxt_switches = voluntary_ctxt_switches + nonvoluntary_ctxt_switches; - opentelemetry::nostd::get>>(observer_result)->Observe(total_ctxt_switches); + opentelemetry::nostd::get>>(observer_result)->Observe(voluntary_ctxt_switches, {{"type", "voluntary_ctxt_switches"}}); + opentelemetry::nostd::get>>(observer_result)->Observe(nonvoluntary_ctxt_switches, {{"type", "nonvoluntary_ctxt_switches"}}); } From 8a95f49bfa60649c02ae1989e4c89ddbb628f810 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Thu, 17 Nov 2022 13:54:13 -0800 Subject: [PATCH 13/13] Fix --- .../process_metrics/example/metrics_example.cc | 2 +- instrumentation/process_metrics/src/test_lib.cc | 16 ++++++++-------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/instrumentation/process_metrics/example/metrics_example.cc b/instrumentation/process_metrics/example/metrics_example.cc index 67e631944..0d23a77d1 100644 --- a/instrumentation/process_metrics/example/metrics_example.cc +++ b/instrumentation/process_metrics/example/metrics_example.cc @@ -22,7 +22,7 @@ namespace void initMetrics() { std::cout << "\n LALIT->Init metrics\n"; - std::unique_ptr exporter{new exportermetrics::OStreamMetricExporter}; + std::unique_ptr exporter{new exportermetrics::OStreamMetricExporter}; std::string version{"1.2.0"}; std::string schema{"https://opentelemetry.io/schemas/1.2.0"}; diff --git a/instrumentation/process_metrics/src/test_lib.cc b/instrumentation/process_metrics/src/test_lib.cc index aa8dbdb05..b1a55934d 100644 --- a/instrumentation/process_metrics/src/test_lib.cc +++ b/instrumentation/process_metrics/src/test_lib.cc @@ -23,7 +23,7 @@ void TestLib::create_process_cpu_time_observable_counter() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0", "schema"); - cpu_time_obserable_counter_ = meter->CreateLongObservableCounter("process.cpu.time", "des", "unit"); + cpu_time_obserable_counter_ = meter->CreateInt64ObservableCounter("process.cpu.time", "des", "unit"); cpu_time_obserable_counter_->AddCallback(ProcessMetricsFactory::GetProcessCpuTime, nullptr); auto storage = static_cast(cpu_time_obserable_counter_.get())->GetMetricStorage(); } @@ -40,7 +40,7 @@ void TestLib::create_process_memory_usage_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - memory_usage_obserable_gauge_ = meter->CreateLongObservableGauge("process.memory.usage", "des", "unit"); + memory_usage_obserable_gauge_ = meter->CreateInt64ObservableGauge("process.memory.usage", "des", "unit"); memory_usage_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessMemoryUsage, nullptr); } @@ -48,7 +48,7 @@ void TestLib::create_process_memory_virtual_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - memory_virtual_obserable_gauge_ = meter->CreateLongObservableGauge("process.memory.virtual", "des", "unit"); + memory_virtual_obserable_gauge_ = meter->CreateInt64ObservableGauge("process.memory.virtual", "des", "unit"); memory_virtual_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessMemoryVirtual, nullptr); } @@ -56,7 +56,7 @@ void TestLib::create_process_disk_io_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - disk_io_obserable_gauge_ = meter->CreateLongObservableGauge("process.disk.io", "des", "unit"); + disk_io_obserable_gauge_ = meter->CreateInt64ObservableGauge("process.disk.io", "des", "unit"); disk_io_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessDiskIO, nullptr); } @@ -64,7 +64,7 @@ void TestLib::create_process_network_io_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - network_io_obserable_gauge_ = meter->CreateLongObservableGauge("process.network.io", "des", "unit"); + network_io_obserable_gauge_ = meter->CreateInt64ObservableGauge("process.network.io", "des", "unit"); network_io_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessNetworkIO, nullptr); } @@ -72,7 +72,7 @@ void TestLib::create_process_threads_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - threads_obserable_gauge_ = meter->CreateLongObservableGauge("process.threads", "des", "unit"); + threads_obserable_gauge_ = meter->CreateInt64ObservableGauge("process.threads", "des", "unit"); threads_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessThreads, nullptr); } @@ -80,7 +80,7 @@ void TestLib::create_process_open_files_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - open_files_obserable_gauge_ = meter->CreateLongObservableGauge("process.open.files", "des", "unit"); + open_files_obserable_gauge_ = meter->CreateInt64ObservableGauge("process.open.files", "des", "unit"); open_files_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessOpenFileDescriptors, nullptr); } @@ -88,7 +88,7 @@ void TestLib::create_process_context_switches_observable_gauge() { auto provider = metrics_api::Provider::GetMeterProvider(); nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0"); - context_switches_obserable_gauge_ = meter->CreateLongObservableGauge("process.context.switches", "des", "unit"); + context_switches_obserable_gauge_ = meter->CreateInt64ObservableGauge("process.context.switches", "des", "unit"); context_switches_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessContextSwitches, nullptr); }