diff --git a/instrumentation/process_metrics/CMakeLists.txt b/instrumentation/process_metrics/CMakeLists.txt new file mode 100644 index 000000000..9c138b4a8 --- /dev/null +++ b/instrumentation/process_metrics/CMakeLists.txt @@ -0,0 +1,26 @@ +cmake_minimum_required(VERSION 3.12) + +project(opentelemetry-process-metrics) + +add_definitions(-DHAVE_CONSOLE_LOG) + +find_package(opentelemetry-cpp REQUIRED) +find_package(CURL REQUIRED) + +option(WITH_EXAMPLE "Whether to build example code" ON) + + +include_directories(include) +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() + +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 new file mode 100644 index 000000000..0d23a77d1 --- /dev/null +++ b/instrumentation/process_metrics/example/metrics_example.cc @@ -0,0 +1,118 @@ +# 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" + +# include +# include + +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::cout << "\n LALIT->Init metrics\n"; + 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)); + +#if 0 + //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)); + +#endif + metrics_api::Provider::SetMeterProvider(provider); + std::cout << "\n LALIT->Init metrics done\n"; + +} +} // namespace + +int main(int argc, char **argv) +{ + std::vector args(argv + 1, argv + argc); + std::string example_type; + 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); + } + 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/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/include/test_lib.h b/instrumentation/process_metrics/include/test_lib.h new file mode 100644 index 000000000..9758c32d0 --- /dev/null +++ b/instrumentation/process_metrics/include/test_lib.h @@ -0,0 +1,30 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "opentelemetry/nostd/shared_ptr.h" +#include "opentelemetry/metrics/async_instruments.h" +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_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_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/linux/process_cpu_time.cc b/instrumentation/process_metrics/src/linux/process_cpu_time.cc new file mode 100644 index 000000000..f534e9b88 --- /dev/null +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.cc @@ -0,0 +1,50 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#ifdef __linux__ +#include "process_cpu_time.h" +#include +#include +#include +#include + + +long ProcessCpuTime::clock_ticks_per_sec_ = sysconf(_SC_CLK_TCK); + +ProcessCpuTime::ProcessCpuTime() +: number_of_cpus_{std::thread::hardware_concurrency()}, last_clock_time_{std::chrono::high_resolution_clock::now()} +{ + times(&start_time_); + last_cpu_time_ = start_time_; +} + +long ProcessCpuTime::TotalElapsedTime() +{ + 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_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_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 new file mode 100644 index 000000000..79dbc3767 --- /dev/null +++ b/instrumentation/process_metrics/src/linux/process_cpu_time.h @@ -0,0 +1,31 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#ifdef __linux__ +#include +#include +#include + +class ProcessCpuTime +{ + public: + ProcessCpuTime(); + + // returns cpu time (user + system) from beginning + long TotalElapsedTime(); + + // returns cpu time (user + system) since last call to Last*Time() + double LastElapsedTime(); + + // returns cpu utilization + double CpuUtilization(); + + private: + static long clock_ticks_per_sec_; + struct tms start_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 new file mode 100644 index 000000000..2a2b21dbb --- /dev/null +++ b/instrumentation/process_metrics/src/linux/process_metrics_linux_factory.cc @@ -0,0 +1,192 @@ +// Copyright The OpenTelemetry Authors +// 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" +#include "process_cpu_time.h" + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +#include +#include +#include + +using namespace opentelemetry; + +namespace { + + static void ReadProcSelfFileForKey(std::string file_name, std::string key, long &value) { + std::string ret; + 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); + 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()); + value = std::stol(value_str); + found = true; + } + } + } + } + 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*/) + { + static ProcessCpuTime cputime; + 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(); + nostd::get>>(observer_result)->Observe(cpu_utilization); + } + + void ProcessMetricsFactory::GetProcessMemoryUsage(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + { + long rss_bytes = 0; + ReadProcSelfFileForKey("/proc/self/status", "VmRSS", rss_bytes); + if (rss_bytes >= 0) { + rss_bytes = rss_bytes * 1024 ; //bytes + nostd::get>>(observer_result)->Observe(rss_bytes); + } + } + + void ProcessMetricsFactory::GetProcessMemoryVirtual(opentelemetry::metrics::ObserverResult observer_result, void * /*state*/) + { + long vm_bytes = 0; + ReadProcSelfFileForKey("/proc/self/status", "VmSize", vm_bytes); + if (vm_bytes >= 0) { + vm_bytes = vm_bytes * 1024 ; //bytes + 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 ){ + nostd::get>>(observer_result)->Observe(read_bytes, {{"direction", "read"}}); + } + ReadProcSelfFileForKey("/proc/self/io", "write_bytes", write_bytes); + if (write_bytes >= 0 ){ + nostd::get>>(observer_result)->Observe(write_bytes, {{"direction", "write"}}); + } + } + + 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 ) { + nostd::get>>(observer_result)->Observe(read_bytes, {{"direction", "receive"}}); + } + if (write_bytes > 0){ + 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*/) + { + 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(voluntary_ctxt_switches, {{"type", "voluntary_ctxt_switches"}}); + opentelemetry::nostd::get>>(observer_result)->Observe(nonvoluntary_ctxt_switches, {{"type", "nonvoluntary_ctxt_switches"}}); + } + + + + +#endif 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/process_metrics/src/test_lib.cc b/instrumentation/process_metrics/src/test_lib.cc new file mode 100644 index 000000000..b1a55934d --- /dev/null +++ b/instrumentation/process_metrics/src/test_lib.cc @@ -0,0 +1,94 @@ +#include "../include/test_lib.h" +#include "../include/process_metrics_factory.h" +# 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 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() +{ + auto provider = metrics_api::Provider::GetMeterProvider(); + nostd::shared_ptr meter = provider->GetMeter("process.metrics", "1.2.0", "schema"); + 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(); +} + +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->CreateDoubleObservableGauge("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"); + memory_usage_obserable_gauge_ = meter->CreateInt64ObservableGauge("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"); + memory_virtual_obserable_gauge_ = meter->CreateInt64ObservableGauge("process.memory.virtual", "des", "unit"); + memory_virtual_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessMemoryVirtual, nullptr); +} + +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->CreateInt64ObservableGauge("process.disk.io", "des", "unit"); + disk_io_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessDiskIO, nullptr); +} + +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->CreateInt64ObservableGauge("process.network.io", "des", "unit"); + network_io_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessNetworkIO, nullptr); +} + +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->CreateInt64ObservableGauge("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"); + open_files_obserable_gauge_ = meter->CreateInt64ObservableGauge("process.open.files", "des", "unit"); + open_files_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessOpenFileDescriptors, nullptr); +} + +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->CreateInt64ObservableGauge("process.context.switches", "des", "unit"); + context_switches_obserable_gauge_->AddCallback(ProcessMetricsFactory::GetProcessContextSwitches, nullptr); + +} 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