From f6a1c5535381f05a747c0f2c25d24d76a59545e6 Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Mon, 25 Sep 2023 12:24:10 -0400 Subject: [PATCH 01/40] feat: metric_exporter, metric_reader draft version of metric reader and exporter --- .../+exporters/+otlp/OtlpGrpcMetricExporter.m | 135 ++++++++++++++++++ .../+exporters/+otlp/OtlpHttpMetricExporter.m | 131 +++++++++++++++++ .../+exporters/+otlp/defaultMetricExporter.m | 16 +++ .../otlp/OtlpGrpcMetricExporterProxy.h | 32 +++++ .../otlp/OtlpHttpMetricExporterProxy.h | 32 +++++ exporters/otlp/src/OtlpGrpcMetricExporter.cpp | 69 +++++++++ .../otlp/src/OtlpHttpMetricExporterProxy.cpp | 0 .../+sdk/+metrics/MetricExporter.m | 21 +++ .../+metrics/PeriodicExportingMetricReader.m | 58 ++++++++ .../sdk/metrics/MetricExporterProxy.h | 16 +++ .../metrics/PeriodicExportingMetricReader.h | 28 ++++ .../src/PeriodicExportingMetricReader.cpp | 23 +++ 12 files changed, 561 insertions(+) create mode 100644 exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m create mode 100644 exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m create mode 100644 exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m create mode 100644 exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h create mode 100644 exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h create mode 100644 exporters/otlp/src/OtlpGrpcMetricExporter.cpp create mode 100644 exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp create mode 100644 sdk/metrics/+opentelemetry/+sdk/+metrics/MetricExporter.m create mode 100644 sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m create mode 100644 sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h create mode 100644 sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReader.h create mode 100644 sdk/metrics/src/PeriodicExportingMetricReader.cpp diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m new file mode 100644 index 0000000..2f4a958 --- /dev/null +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m @@ -0,0 +1,135 @@ +classdef OtlpGrpcMetricExporter < opentelemetry.sdk.metrics.MetricExporter +% OtlpGrpcMetricExporter exports Metrics in OpenTelemetry Protocol format via +% gRPC. By default, it exports to the default address of the OpenTelemetry +% Collector. + +% Copyright 2023 The MathWorks, Inc. + + properties (SetAccess=immutable) + Endpoint (1,1) string % Export destination + UseCredentials (1,1) logical % Whether to use SSL credentials + CertificatePath (1,1) string % Path to .pem file for SSL encryption + CertificateString (1,1) string % In-memory string representation of .pem file for SSL encryption + Timeout (1,1) duration % Maximum time above which exports will abort + HttpHeaders (1,1) dictionary % Additional HTTP headers + end + + methods + function obj = OtlpGrpcMetricExporter(optionnames, optionvalues) + % OtlpGrpcMetricExporter exports Metrics in OpenTelemetry Protocol format via gRPC. + % EXP = OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMetricEXPORTER + % creates an exporter that uses default configurations. + % + % EXP = + % OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMetricEXPORTER(PARAM1, + % VALUE1, PARAM2, VALUE2, ...) specifies optional parameter + % name/value pairs. Parameters are: + % "Endpoint" - Endpoint to export to + % "UseCredentials" - Whether to use SSL credentials. + % Default is false. If true, use + % .pem file specified in + % "CertificatePath" or + % "CertificateString". + % "CertificatePath" - Path to .pem file for SSL encryption + % "CertificateString" - .pem file specified in memory as + % a string + % "Timeout" - Maximum time above which exports + % will abort + % "HTTPHeaders" - Additional HTTP Headers + % + % See also OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMetricEXPORTER + arguments (Repeating) + optionnames (1,:) {mustBeTextScalar} + optionvalues + end + + validnames = ["Endpoint", "UseCredentials ", "CertificatePath", ... + "CertificateString", "Timeout", "HttpHeaders"]; + % set default values to empty or negative + endpoint = ""; + usessl = false; + certificatepath = ""; + certificatestring = ""; + timeout_millis = -1; + headerkeys = string.empty(); + headervalues = string.empty(); + for i = 1:length(optionnames) + namei = validatestring(optionnames{i}, validnames); + valuei = optionvalues{i}; + if strcmp(namei, "Endpoint") + if ~(isStringScalar(valuei) || (ischar(valuei) && isrow(valuei))) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:EndpointNotScalarText", "Endpoint must be a scalar string."); + end + endpoint = string(valuei); + elseif strcmp(namei, "UseCredentials ") + if ~((islogical(valuei) || isnumeric(valuei)) && isscalar(valuei)) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:UseCredentialsNotScalarLogical", "UseCredentials must be a scalar logical.") + end + usessl = logical(valuei); + elseif strcmp(namei, "CertificatePath") + if ~(isStringScalar(valuei) || (ischar(valuei) && isrow(valuei))) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:CertificatePathNotScalarText", "CertificatePath must be a scalar string."); + end + certificatepath = string(valuei); + elseif strcmp(namei, "CertificateString") + if ~(isStringScalar(valuei) || (ischar(valuei) && isrow(valuei))) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:CertificateStringNotScalarText", "CertificateString must be a scalar string."); + end + certificatestring = string(valuei); + elseif strcmp(namei, "Timeout") + if ~(isduration(valuei) && isscalar(valuei)) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:TimeoutNotScalarDuration", "Timeout must be a scalar duration."); + end + timeout = valuei; + timeout_millis = milliseconds(timeout); + else % HttpHeaders + if ~isa(valuei, "dictionary") + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:HttpHeadersNotDictionary", "HttpHeaders input must be a dictionary."); + end + httpheaders = valuei; + headerkeys = keys(valuei); + headervalues = values(valuei); + if ~isstring(headervalues) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:HttpHeadersNonStringValues", "HttpHeaders dictionary values must be strings.") + end + end + end + + obj = obj@opentelemetry.sdk.metrics.MetricExporter(... + "libmexclass.opentelemetry.exporters.OtlpGrpcMetricExporterProxy", ... + endpoint, usessl, certificatepath, certificatestring, ... + timeout_millis, headerkeys, headervalues); + + % populate immutable properties + [defaultendpoint, defaultcertpath, defaultcertstring, defaultmillis] = ... + getDefaultOptionValues(obj); + if endpoint == "" % not specified, use default value + obj.Endpoint = defaultendpoint; + else + obj.Endpoint = endpoint; + end + obj.UseCredentials = usessl; + if certificatepath == "" % not specified, use default value + obj.CertificatePath = defaultcertpath; + else + obj.CertificatePath = certificatepath; + end + if certificatestring == "" % not specified, use default value + obj.CertificateString = defaultcertstring; + else + obj.CertificateString = certificatestring; + end + if timeout_millis < 0 % not specified, use default value + obj.Timeout = milliseconds(defaultmillis); + else + obj.Timeout = timeout; + end + if isempty(headerkeys) % not specified, return empty dictionary + obj.HttpHeaders = dictionary(headerkeys, headervalues); + else + obj.HttpHeaders = httpheaders; + end + + end + end +end diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m new file mode 100644 index 0000000..36c35cf --- /dev/null +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m @@ -0,0 +1,131 @@ +classdef OtlpHttpMetricExporter < opentelemetry.sdk.metrics.MetricExporter +% OtlpHttpMetricExporter exports Metrics in OpenTelemetry Protocol format via +% HTTP. By default, it exports to the default address of the OpenTelemetry +% Collector. + +% Copyright 2023 The MathWorks, Inc. + + properties (SetAccess=immutable) + Endpoint (1,1) string % Export destination + Format (1,1) string % Data format, JSON or binary + JsonBytesMapping (1,1) string % What to convert JSON bytes to + UseJsonName (1,1) logical % Whether to use JSON name of protobuf field to set the key of JSON + Timeout (1,1) duration % Maximum time above which exports will abort + HttpHeaders (1,1) dictionary % Additional HTTP headers + end + + methods + function obj = OtlpHttpMetricExporter(optionnames, optionvalues) + % OtlpHttpMetricExporter exports Metrics in OpenTelemetry Protocol format via HTTP. + % EXP = OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMetricEXPORTER + % creates an exporter that uses default configurations. + % + % EXP = + % OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMetricEXPORTER(PARAM1, + % VALUE1, PARAM2, VALUE2, ...) specifies optional parameter + % name/value pairs. Parameters are: + % "Endpoint" - Endpoint to export to + % "Format" - Data format: "JSON" (default) or "binary" + % "JsonBytesMapping" - What to convert JSON bytes to. Supported + % values are "hex", "hexId" (default), and + % "base64". Default "hexId" + % converts to base 64 except for IDs + % which are converted to hexadecimals. + % "UseJsonName" - Whether to use JSON name of protobuf + % field to set the key of JSON + % "Timeout" - Maximum time above which exports + % will abort + % "HTTPHeaders" - Additional HTTP Headers + % + % See also OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMetricEXPORTER + arguments (Repeating) + optionnames (1,:) {mustBeTextScalar} + optionvalues + end + + validnames = ["Endpoint", "Format", "JsonBytesMapping", ... + "UseJsonName", "Timeout", "HttpHeaders"]; + % set default values to empty or negative + endpoint = ""; + dataformat = ""; + jsonbytesmapping = ""; + usejsonname = false; + timeout_millis = -1; + headerkeys = string.empty(); + headervalues = string.empty(); + for i = 1:length(optionnames) + namei = validatestring(optionnames{i}, validnames); + valuei = optionvalues{i}; + if strcmp(namei, "Endpoint") + if ~(isStringScalar(valuei) || (ischar(valuei) && isrow(valuei))) + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:EndpointNotScalarText", "Endpoint must be a scalar string."); + end + endpoint = string(valuei); + elseif strcmp(namei, "Format") + dataformat = validatestring(valuei, ["JSON", "binary"]); + elseif strcmp(namei, "JsonBytesMapping") + jsonbytesmapping = validatestring(valuei, ["hex", "hexId", "base64"]); + elseif strcmp(namei, "UseJsonName") + if ~((islogical(valuei) || isnumeric(valuei)) && isscalar(valuei)) + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:UseJsonNameNotScalarLogical", "UseJsonName must be a scalar logical.") + end + usejsonname = logical(valuei); + elseif strcmp(namei, "Timeout") + if ~(isduration(valuei) && isscalar(valuei)) + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:TimeoutNotScalarDuration", "Timeout must be a scalar duration."); + end + timeout = valuei; + timeout_millis = milliseconds(timeout); + else % HttpHeaders + if ~isa(valuei, "dictionary") + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:HttpHeadersNotDictionary", "HttpHeaders input must be a dictionary."); + end + httpheaders = valuei; + headerkeys = keys(valuei); + headervalues = values(valuei); + if ~isstring(headervalues) + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:HttpHeadersNonStringValues", "HttpHeaders dictionary values must be strings.") + end + end + end + + obj = obj@opentelemetry.sdk.metrics.MetricExporter(... + "libmexclass.opentelemetry.exporters.OtlpHttpMetricExporterProxy", ... + endpoint, dataformat, jsonbytesmapping, usejsonname, ... + timeout_millis, headerkeys, headervalues); + + % populate immutable properties + if endpoint == "" || dataformat == "" || jsonbytesmapping == "" || ... + timeout_millis < 0 + [defaultendpoint, defaultformat, defaultmapping, defaultmillis] = ... + getDefaultOptionValues(obj); + end + if endpoint == "" % not specified, use default value + obj.Endpoint = defaultendpoint; + else + obj.Endpoint = endpoint; + end + if dataformat == "" % not specified, use default value + obj.Format = defaultformat; + else + obj.Format = dataformat; + end + if jsonbytesmapping == "" % not specified, use default value + obj.JsonBytesMapping = defaultmapping; + else + obj.JsonBytesMapping = jsonbytesmapping; + end + obj.UseJsonName = usejsonname; + if timeout_millis < 0 % not specified, use default value + obj.Timeout = milliseconds(defaultmillis); + else + obj.Timeout = timeout; + end + if isempty(headerkeys) % not specified, return empty dictionary + obj.HttpHeaders = dictionary(headerkeys, headervalues); + else + obj.HttpHeaders = httpheaders; + end + end + end +end diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m new file mode 100644 index 0000000..a478fd2 --- /dev/null +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m @@ -0,0 +1,16 @@ +function dexp = defaultMetricExporter +% Get the default Metric exporter depending on installation +% EXP = OPENTELEMETRY.EXPORTERS.OTLP.DEFAULTMetricEXPORTER returns the +% default Metric exporter. OtlpHttpMetricExporter is the default if it is +% installed. Otherwise, OtlpGrpcMetricExporter is the default. +% +% See also OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMetricEXPORTER, +% OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMetricEXPORTER + +% Copyright 2023 The MathWorks, Inc. + +if exist("opentelemetry.exporters.otlp.OtlpHttpMetricExporter", "class") + dexp = opentelemetry.exporters.otlp.OtlpHttpMetricExporter; +else + dexp = opentelemetry.exporters.otlp.OtlpGrpcMetricExporter; +end diff --git a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h new file mode 100644 index 0000000..757de20 --- /dev/null +++ b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h @@ -0,0 +1,32 @@ +// Copyright 2023 The MathWorks, Inc. + +#pragma once + +#include "opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h" + +#include "libmexclass/proxy/Proxy.h" +#include "libmexclass/proxy/method/Context.h" + +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" +#include "opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h" + +namespace metric_sdk = opentelemetry::sdk::metric; +namespace otlp_exporter = opentelemetry::exporter::otlp; + +namespace libmexclass::opentelemetry::exporters { +class OtlpGrpcMetricExporterProxy: public libmexclass::opentelemetry::sdk::MetricExporterProxy { + public: + OtlpGrpcMetricExporterProxy(otlp_exporter::OtlpGrpcExporterOptions options) : CppOptions(options) { + REGISTER_METHOD(OtlpGrpcMetricExporterProxy, getDefaultOptionValues); + } + + static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); + + std::unique_ptr getInstance() override; + + void getDefaultOptionValues(libmexclass::proxy::method::Context& context); + + private: + otlp_exporter::OtlpGrpcExporterOptions CppOptions; +}; +} // namespace libmexclass::opentelemetry diff --git a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h new file mode 100644 index 0000000..9f36f9a --- /dev/null +++ b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h @@ -0,0 +1,32 @@ +// Copyright 2023 The MathWorks, Inc. + +#pragma once + +#include "opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h" + +#include "libmexclass/proxy/Proxy.h" +#include "libmexclass/proxy/method/Context.h" + +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" +#include "opentelemetry/exporters/otlp/otlp_http_exporter_options.h" + +namespace metric_sdk = opentelemetry::sdk::metrics; +namespace otlp_exporter = opentelemetry::exporter::otlp; + +namespace libmexclass::opentelemetry::exporters { +class OtlpHttpMetricExporterProxy: public libmexclass::opentelemetry::sdk::MetricExporterProxy { + public: + OtlpHttpMetricExporterProxy(otlp_exporter::OtlpHttpExporterOptions options) : CppOptions(options) { + REGISTER_METHOD(OtlpHttpMetricExporterProxy, getDefaultOptionValues); + } + + static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); + + std::unique_ptr getInstance() override; + + void getDefaultOptionValues(libmexclass::proxy::method::Context& context); + + private: + otlp_exporter::OtlpHttpExporterOptions CppOptions; +}; +} // namespace libmexclass::opentelemetry diff --git a/exporters/otlp/src/OtlpGrpcMetricExporter.cpp b/exporters/otlp/src/OtlpGrpcMetricExporter.cpp new file mode 100644 index 0000000..e17a4fa --- /dev/null +++ b/exporters/otlp/src/OtlpGrpcMetricExporter.cpp @@ -0,0 +1,69 @@ +// Copyright 2023 The MathWorks, Inc. + +#include "opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h" + +#include "libmexclass/proxy/ProxyManager.h" + +#include "opentelemetry/exporters/otlp/otlp_grpc_exporter_factory.h" + +namespace otlp_exporter = opentelemetry::exporter::otlp; + +namespace libmexclass::opentelemetry::exporters { +libmexclass::proxy::MakeResult OtlpGrpcMetricExporterProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { + matlab::data::StringArray endpoint_mda = constructor_arguments[0]; + std::string endpoint = static_cast(endpoint_mda[0]); + matlab::data::TypedArray use_ssl_mda = constructor_arguments[1]; + bool use_ssl = use_ssl_mda[0]; + matlab::data::StringArray certpath_mda = constructor_arguments[2]; + std::string certpath = static_cast(certpath_mda[0]); + matlab::data::StringArray certstring_mda = constructor_arguments[3]; + std::string certstring = static_cast(certstring_mda[0]); + matlab::data::TypedArray timeout_mda = constructor_arguments[4]; + double timeout = timeout_mda[0]; + matlab::data::Array header_mda = constructor_arguments[5]; + size_t nheaders = header_mda.getNumberOfElements(); + matlab::data::StringArray headernames_mda = constructor_arguments[5]; + matlab::data::StringArray headervalues_mda = constructor_arguments[6]; + + otlp_exporter::OtlpGrpcExporterOptions options; + if (!endpoint.empty()) { + options.endpoint = endpoint; + } + // use_ssl + options.use_ssl_credentials = use_ssl; + if (!certpath.empty()) { + options.ssl_credentials_cacert_path = certpath; + } + if (!certstring.empty()) { + options.ssl_credentials_cacert_as_string = certstring; + } + // timeout + if (timeout >= 0) { + options.timeout = std::chrono::milliseconds(static_cast(timeout)); + } + // http headers + for (size_t i = 0; i < nheaders; ++i) { + options.metadata.insert(std::pair{static_cast(headernames_mda[i]), + static_cast(headervalues_mda[i])}); + } + return std::make_shared(options); +} + +std::unique_ptr OtlpGrpcMetricExporterProxy::getInstance() { + return otlp_exporter::OtlpGrpcExporterFactory::Create(CppOptions); +} + +void OtlpGrpcMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::method::Context& context) { + otlp_exporter::OtlpGrpcExporterOptions options; + matlab::data::ArrayFactory factory; + auto endpoint_mda = factory.createScalar(options.endpoint); + auto certpath_mda = factory.createScalar(options.ssl_credentials_cacert_path); + auto certstring_mda = factory.createScalar(options.ssl_credentials_cacert_as_string); + auto timeout_millis = std::chrono::duration_cast(options.timeout); + auto timeout_mda = factory.createScalar(static_cast(timeout_millis.count())); + context.outputs[0] = endpoint_mda; + context.outputs[1] = certpath_mda; + context.outputs[2] = certstring_mda; + context.outputs[3] = timeout_mda; +} +} // namespace libmexclass::opentelemetry diff --git a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp new file mode 100644 index 0000000..e69de29 diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MetricExporter.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MetricExporter.m new file mode 100644 index 0000000..c1fbd49 --- /dev/null +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MetricExporter.m @@ -0,0 +1,21 @@ +classdef MetricExporter +% Base class of metric exporters + +% Copyright 2023 The MathWorks, Inc. + + properties (Access=?opentelemetry.sdk.metrics.PeriodicExportingMetricReader) + Proxy % Proxy object to interface C++ code + end + + methods (Access=protected) + function obj = MetricExporter(proxyname, varargin) + % Base class constructor + obj.Proxy = libmexclass.proxy.Proxy("Name", proxyname, ... + "ConstructorArguments", varargin); + end + + function varargout = getDefaultOptionValues(obj) + [varargout{1:nargout}] = obj.Proxy.getDefaultOptionValues(); + end + end +end diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m new file mode 100644 index 0000000..d7604dd --- /dev/null +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m @@ -0,0 +1,58 @@ +classdef PeriodicExportingMetricReader < matlab.mixin.Heterogeneous +% Base class of metric reader + +% Copyright 2023 The MathWorks, Inc. + + properties (GetAccess=?opentelemetry.sdk.metrics.MeterProvider) + Proxy % Proxy object to interface C++ code + end + + properties (SetAccess=immutable) + MetircExporter % Metric exporter object responsible for exporting telemetry data to an OpenTelemetry Collector or a compatible backend. + Interval (1,1) double % Maximum queue size. After queue size is reached, spans are dropped. + Timeout (1,1) double + end + + methods (Access=protected) + function obj = PeriodicExportingMetricReader(metricexporter, optionnames, optionvalues) + + arguments + metricexporter {mustBeA(metricexporter, "opentelemetry.sdk.metrics.MetricExporter")} = ... + opentelemetry.exporters.otlp.defaultMetricExporter() + end + arguments (Repeating) + optionnames (1,:) {mustBeTextScalar} + optionvalues + end + + validnames = ["Interval", "Timeout"]; + % set default values + intervalmills = 60; + timeoutmills = 30; + for i = 1:length(optionnames) + namei = validatestring(optionnames{i}, validnames); + valuei = optionvalues{i}; + if strcmp(namei, "Interval") + if ~isnumeric(valuei) || ~isscalar(valuei) || valuei <= 0 || ... + round(valuei) ~= valuei + error("opentelemetry:sdk:metrics::PeriodicExportingMetricReader::InvalidInterval", ... + "Interval must be a scalar positive integer."); + end + intervalmills = double(valuei); + elseif strcmp(namei, "Timeout") + if ~isduration(valuei) || ~isscalar(valuei) || valuei <= 0 + error("opentelemetry:sdk:metrics:PeriodicExportingMetricReader:InvalidTimeout", ... + "Timeout must be a positive duration scalar."); + end + timeoutmillis = milliseconds(valuei); + end + + obj.MetricExporter = metricexporter; + obj.Interval = intervalmills; + obj.Timeout = timeoutmillis; + obj.Proxy = libmexclass.proxy.Proxy("Name", "libmexclass.opentelemetry.sdk.PeriodicExportingMetricReaderProxy" , ... + "ConstructorArguments", [metricexporter.Proxy.ID, Interval, Timeout]); + + end + end +end diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h new file mode 100644 index 0000000..0fb9b89 --- /dev/null +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h @@ -0,0 +1,16 @@ +// Copyright 2023 The MathWorks, Inc. + +#pragma once + +#include "libmexclass/proxy/Proxy.h" + +#include "opentelemetry/sdk/metrics/push_metric_exporter.h" + +namespace metric_sdk = opentelemetry::sdk::metric; + +namespace libmexclass::opentelemetry::sdk { +class MetricExporterProxy : public libmexclass::proxy::Proxy { + public: + virtual std::unique_ptr getInstance() = 0; +}; +} // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReader.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReader.h new file mode 100644 index 0000000..970996f --- /dev/null +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReader.h @@ -0,0 +1,28 @@ +// Copyright 2023 The MathWorks, Inc. + +#pragma once + +#include "opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h" + +#include "libmexclass/proxy/Proxy.h" +#include "libmexclass/proxy/method/Context.h" + +#include "opentelemetry/sdk/metrics/periodic_exporting_metric_reader_options.h" + +namespace metric_reader_sdk = opentelemetry::sdk::metrics::MetricReader; + +namespace libmexclass::opentelemetry::sdk { +class PeriodicExportingMetricReaderProxy : public libmexclass::proxy::Proxy { + public: + PeriodicExportingMetricReaderProxy(std::shared_ptr exporter, double interval, double timeout); + + static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); + + std::unique_ptr getInstance(); + + void getDefaultOptionValues(libmexclass::proxy::method::Context& context); + + private: + metric_reader_sdk::PeriodicExportingMetricReaderOptions CppOptions; +}; +} // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/src/PeriodicExportingMetricReader.cpp b/sdk/metrics/src/PeriodicExportingMetricReader.cpp new file mode 100644 index 0000000..de6d6f9 --- /dev/null +++ b/sdk/metrics/src/PeriodicExportingMetricReader.cpp @@ -0,0 +1,23 @@ +// Copyright 2023 The MathWorks, Inc. + +#pragma once + +#include "opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReader.h" + + +namespace libmexclass::opentelemetry::sdk { +libmexclass::proxy::MakeResult PeriodicExportingMetricReaderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments){ + + libmexclass::proxy::MakeResult out; + + return out + +} + + +//std::unique_ptr PeriodicExportingMetricReaderProxy::getInstance() + + +//void PeriodicExportingMetricReaderProxy::getDefaultOptionValues(libmexclass::proxy::method::Context& context) + +} // namespace libmexclass::opentelemetry From 0984062aa26c92a3e7dfa5ffc84163fc3376f5b5 Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Wed, 27 Sep 2023 12:18:27 -0400 Subject: [PATCH 02/40] update 1 --- .gitignore | 1 + CMakeLists.txt | 7 ++ exporters/otlp/src/OtlpGrpcMetricExporter.cpp | 8 +- .../otlp/src/OtlpHttpMetricExporterProxy.cpp | 93 +++++++++++++++++++ .../+sdk/+metrics/MeterProvider.m | 21 ++++- .../+metrics/PeriodicExportingMetricReader.m | 11 ++- .../sdk/metrics/MeterProviderProxy.h | 3 + .../sdk/metrics/MetricExporterProxy.h | 2 +- ...h => PeriodicExportingMetricReaderProxy.h} | 11 ++- sdk/metrics/src/MeterProviderProxy.cpp | 27 +++++- .../src/PeriodicExportingMetricReader.cpp | 23 ----- .../PeriodicExportingMetricReaderProxy.cpp | 59 ++++++++++++ 12 files changed, 222 insertions(+), 44 deletions(-) rename sdk/metrics/include/opentelemetry-matlab/sdk/metrics/{PeriodicExportingMetricReader.h => PeriodicExportingMetricReaderProxy.h} (63%) delete mode 100644 sdk/metrics/src/PeriodicExportingMetricReader.cpp create mode 100644 sdk/metrics/src/PeriodicExportingMetricReaderProxy.cpp diff --git a/.gitignore b/.gitignore index b3ec7c2..dbf01a4 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ build # Autosave files *.asv *.swp +.vscode/settings.json diff --git a/CMakeLists.txt b/CMakeLists.txt index cadc935..2fac526 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -229,6 +229,7 @@ set(OPENTELEMETRY_PROXY_SOURCES ${TRACE_SDK_SOURCE_DIR}/BatchSpanProcessorProxy.cpp ${TRACE_SDK_SOURCE_DIR}/ParentBasedSamplerProxy.cpp ${METRICS_SDK_SOURCE_DIR}/MeterProviderProxy.cpp + ${METRICS_SDK_SOURCE_DIR}/PeriodicExportingMetricReaderProxy.cpp ${COMMON_SDK_SOURCE_DIR}/resource.cpp) if(WITH_OTLP_HTTP) set(OPENTELEMETRY_PROXY_SOURCES ${OPENTELEMETRY_PROXY_SOURCES} @@ -391,6 +392,9 @@ set(METRICS_SDK_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/sdk/metrics/+opentele set(DEFAULT_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultSpanExporter.m) set(OTLP_HTTP_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpSpanExporter.m) set(OTLP_GRPC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcSpanExporter.m) +set(DEFAULT_METRIC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m) +set(OTLP_HTTP_METRIC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m) +set(OTLP_GRPC_METRIC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m) set(OTLP_EXPORTERS_DIR +opentelemetry/+exporters/+otlp) @@ -402,11 +406,14 @@ install(DIRECTORY ${COMMON_API_MATLAB_SOURCES} DESTINATION .) install(DIRECTORY ${TRACE_SDK_MATLAB_SOURCES} DESTINATION .) install(DIRECTORY ${METRICS_SDK_MATLAB_SOURCES} DESTINATION .) install(FILES ${DEFAULT_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) +install(FILES ${DEFAULT_METRIC_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) if(WITH_OTLP_HTTP) install(FILES ${OTLP_HTTP_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) + install(FILES ${OTLP_HTTP_METRIC_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) endif() if(WITH_OTLP_GRPC) install(FILES ${OTLP_GRPC_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) + install(FILES ${OTLP_GRPC_METRIC_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) endif() # Install dependent runtime libraries diff --git a/exporters/otlp/src/OtlpGrpcMetricExporter.cpp b/exporters/otlp/src/OtlpGrpcMetricExporter.cpp index e17a4fa..17474f2 100644 --- a/exporters/otlp/src/OtlpGrpcMetricExporter.cpp +++ b/exporters/otlp/src/OtlpGrpcMetricExporter.cpp @@ -4,7 +4,7 @@ #include "libmexclass/proxy/ProxyManager.h" -#include "opentelemetry/exporters/otlp/otlp_grpc_exporter_factory.h" +#include "opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_factory.h" namespace otlp_exporter = opentelemetry::exporter::otlp; @@ -25,7 +25,7 @@ libmexclass::proxy::MakeResult OtlpGrpcMetricExporterProxy::make(const libmexcla matlab::data::StringArray headernames_mda = constructor_arguments[5]; matlab::data::StringArray headervalues_mda = constructor_arguments[6]; - otlp_exporter::OtlpGrpcExporterOptions options; + otlp_exporter::OtlpGrpcMetricExporterOptions options; if (!endpoint.empty()) { options.endpoint = endpoint; } @@ -50,11 +50,11 @@ libmexclass::proxy::MakeResult OtlpGrpcMetricExporterProxy::make(const libmexcla } std::unique_ptr OtlpGrpcMetricExporterProxy::getInstance() { - return otlp_exporter::OtlpGrpcExporterFactory::Create(CppOptions); + return otlp_exporter::OtlpGrpcMetricExporterFactory::Create(CppOptions); } void OtlpGrpcMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::method::Context& context) { - otlp_exporter::OtlpGrpcExporterOptions options; + otlp_exporter::OtlpGrpcMetricExporterOptions options; matlab::data::ArrayFactory factory; auto endpoint_mda = factory.createScalar(options.endpoint); auto certpath_mda = factory.createScalar(options.ssl_credentials_cacert_path); diff --git a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp index e69de29..989348e 100644 --- a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp +++ b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp @@ -0,0 +1,93 @@ +// Copyright 2023 The MathWorks, Inc. + +#include "opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h" + +#include "libmexclass/proxy/ProxyManager.h" + +#include "opentelemetry/exporters/otlp/otlp_http_metric_exporter_factory.h" + +namespace otlp_exporter = opentelemetry::exporter::otlp; + +namespace libmexclass::opentelemetry::exporters { +libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { + matlab::data::StringArray endpoint_mda = constructor_arguments[0]; + std::string endpoint = static_cast(endpoint_mda[0]); + matlab::data::StringArray dataformat_mda = constructor_arguments[1]; + std::string dataformat = static_cast(dataformat_mda[0]); + matlab::data::StringArray json_bytes_mapping_mda = constructor_arguments[2]; + std::string json_bytes_mapping = static_cast(json_bytes_mapping_mda[0]); + matlab::data::TypedArray use_json_name_mda = constructor_arguments[3]; + bool use_json_name = use_json_name_mda[0]; + matlab::data::TypedArray timeout_mda = constructor_arguments[4]; + double timeout = timeout_mda[0]; + matlab::data::Array header_mda = constructor_arguments[5]; + size_t nheaders = header_mda.getNumberOfElements(); + matlab::data::StringArray headernames_mda = constructor_arguments[5]; + matlab::data::StringArray headervalues_mda = constructor_arguments[6]; + + otlp_exporter::OtlpHttpMetricExporterOptions options; + if (!endpoint.empty()) { + options.url = endpoint; + } + // TODO: store the relationship between strings and enums in an associative container + // dataformat + if (dataformat.compare("JSON") == 0) { + options.content_type = otlp_exporter::HttpRequestContentType::kJson; + } else if (dataformat.compare("binary") == 0) { + options.content_type = otlp_exporter::HttpRequestContentType::kBinary; + } + // json_bytes_mapping + if (json_bytes_mapping.compare("hex") == 0) { + options.json_bytes_mapping = otlp_exporter::JsonBytesMappingKind::kHex; + } else if (json_bytes_mapping.compare("hexId") == 0) { + options.json_bytes_mapping = otlp_exporter::JsonBytesMappingKind::kHexId; + } else if (json_bytes_mapping.compare("base64") == 0) { + options.json_bytes_mapping = otlp_exporter::JsonBytesMappingKind::kBase64; + } + // use_json_name + options.use_json_name = use_json_name; + // timeout + if (timeout >= 0) { + options.timeout = std::chrono::milliseconds(static_cast(timeout)); + } + // http headers + for (size_t i = 0; i < nheaders; ++i) { + options.http_headers.insert(std::pair{static_cast(headernames_mda[i]), + static_cast(headervalues_mda[i])}); + } + return std::make_shared(options); +} + +std::unique_ptr OtlpHttpMetricExporterProxy::getInstance() { + return otlp_exporter::OtlpHttpMetricExporterFactory::Create(CppOptions); +} + +void OtlpHttpMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::method::Context& context) { + otlp_exporter::OtlpHttpMetricExporterOptions options; + matlab::data::ArrayFactory factory; + auto endpoint_mda = factory.createScalar(options.url); + std::string dataformat, json_bytes_mapping; + // dataformat + if (options.content_type == otlp_exporter::HttpRequestContentType::kJson) { + dataformat = "JSON"; + } else { + dataformat = "binary"; + } + // json_bytes_mapping + if (options.json_bytes_mapping == otlp_exporter::JsonBytesMappingKind::kHex) { + json_bytes_mapping = "hex"; + } else if (options.json_bytes_mapping == otlp_exporter::JsonBytesMappingKind::kHexId) { + json_bytes_mapping = "hexId"; + } else { // kBase64 + json_bytes_mapping = "base64"; + } + auto dataformat_mda = factory.createScalar(dataformat); + auto json_bytes_mapping_mda = factory.createScalar(json_bytes_mapping); + auto timeout_millis = std::chrono::duration_cast(options.timeout); + auto timeout_mda = factory.createScalar(static_cast(timeout_millis.count())); + context.outputs[0] = endpoint_mda; + context.outputs[1] = dataformat_mda; + context.outputs[2] = json_bytes_mapping_mda; + context.outputs[3] = timeout_mda; +} +} // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index ec019eb..ff41370 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -5,11 +5,12 @@ % Copyright 2023 The MathWorks, Inc. properties (Access=private) - Proxy + Proxy + MetricReader end methods - function obj = MeterProvider() + function obj = MeterProvider(reader) % SDK implementation of tracer provider % MP = OPENTELEMETRY.SDK.METRICS.METERPROVIDER creates a meter % provider that uses a periodic exporting metric reader and default configurations. @@ -28,6 +29,12 @@ % See also OPENTELEMETRY.SDK.METRICS.PERIODICEXPORTINGMETRICREADER % OPENTELEMETRY.SDK.METRICS.VIEW + arguments + reader {mustBeA(reader, ["opentelemetry.sdk.metrics.PeriodicExportingMetricReader", ... + "libmexclass.proxy.Proxy"])} = ... + opentelemetry.sdk.metrics.PeriodicExportingMetricReader() + end + obj.Proxy = libmexclass.proxy.Proxy("Name", ... "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... "ConstructorArguments", {}); @@ -52,5 +59,15 @@ meter = opentelemetry.metrics.Meter(Meterproxy, mtname, mtversion, mtschema); end + + function success = shutdown(obj) + if ~obj.isShutdown + success = obj.Proxy.shutdown(); + obj.isShutdown = success; + else + success = true; + end + end + end end diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m index d7604dd..6fe89bd 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m @@ -13,7 +13,7 @@ Timeout (1,1) double end - methods (Access=protected) + methods (Access=?opentelemetry.sdk.metrics.MeterProvider) function obj = PeriodicExportingMetricReader(metricexporter, optionnames, optionvalues) arguments @@ -27,8 +27,8 @@ validnames = ["Interval", "Timeout"]; % set default values - intervalmills = 60; - timeoutmills = 30; + intervalmillis = 60; + timeoutmillis = 30; for i = 1:length(optionnames) namei = validatestring(optionnames{i}, validnames); valuei = optionvalues{i}; @@ -38,17 +38,18 @@ error("opentelemetry:sdk:metrics::PeriodicExportingMetricReader::InvalidInterval", ... "Interval must be a scalar positive integer."); end - intervalmills = double(valuei); + intervalmillis = double(valuei); elseif strcmp(namei, "Timeout") if ~isduration(valuei) || ~isscalar(valuei) || valuei <= 0 error("opentelemetry:sdk:metrics:PeriodicExportingMetricReader:InvalidTimeout", ... "Timeout must be a positive duration scalar."); end timeoutmillis = milliseconds(valuei); + end end obj.MetricExporter = metricexporter; - obj.Interval = intervalmills; + obj.Interval = intervalmillis; obj.Timeout = timeoutmillis; obj.Proxy = libmexclass.proxy.Proxy("Name", "libmexclass.opentelemetry.sdk.PeriodicExportingMetricReaderProxy" , ... "ConstructorArguments", [metricexporter.Proxy.ID, Interval, Timeout]); diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h index 3526822..cc1f8eb 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h @@ -36,12 +36,15 @@ class MeterProviderProxy : public libmexclass::proxy::Proxy { public: MeterProviderProxy(nostd::shared_ptr mp) : CppMeterProvider(mp) { REGISTER_METHOD(MeterProviderProxy, getMeter); + REGISTER_METHOD(MeterProviderProxy, addMetricReader); } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); void getMeter(libmexclass::proxy::method::Context& context); + void addMetricReader(libmexclass::proxy::method::Context& context); + protected: nostd::shared_ptr CppMeterProvider; }; diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h index 0fb9b89..a7ef1b3 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h @@ -6,7 +6,7 @@ #include "opentelemetry/sdk/metrics/push_metric_exporter.h" -namespace metric_sdk = opentelemetry::sdk::metric; +namespace metric_sdk = opentelemetry::sdk::metrics; namespace libmexclass::opentelemetry::sdk { class MetricExporterProxy : public libmexclass::proxy::Proxy { diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReader.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h similarity index 63% rename from sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReader.h rename to sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h index 970996f..21af4dd 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReader.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h @@ -7,9 +7,10 @@ #include "libmexclass/proxy/Proxy.h" #include "libmexclass/proxy/method/Context.h" -#include "opentelemetry/sdk/metrics/periodic_exporting_metric_reader_options.h" +#include "opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader_factory.h" +#include "opentelemetry/sdk/metrics/export/periodic_exporting_metric_reader_options.h" -namespace metric_reader_sdk = opentelemetry::sdk::metrics::MetricReader; +namespace metric_sdk = opentelemetry::sdk::metrics; namespace libmexclass::opentelemetry::sdk { class PeriodicExportingMetricReaderProxy : public libmexclass::proxy::Proxy { @@ -18,11 +19,13 @@ class PeriodicExportingMetricReaderProxy : public libmexclass::proxy::Proxy { static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); - std::unique_ptr getInstance(); + std::unique_ptr getInstance(); void getDefaultOptionValues(libmexclass::proxy::method::Context& context); private: - metric_reader_sdk::PeriodicExportingMetricReaderOptions CppOptions; + metric_sdk::PeriodicExportingMetricReaderOptions CppOptions; + + std::shared_ptr MetricExporter; }; } // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index e0eb3c3..bea21b4 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -1,6 +1,7 @@ // Copyright 2023 The MathWorks, Inc. #include "opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h" +#include "opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h" #include "libmexclass/proxy/ProxyManager.h" @@ -10,11 +11,11 @@ namespace libmexclass::opentelemetry::sdk { libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { libmexclass::proxy::MakeResult out; - - auto exporter = otlpexporter::OtlpHttpMetricExporterFactory::Create(); - // Initialize and set the periodic metrics reader - metrics_sdk::PeriodicExportingMetricReaderOptions options; - auto reader = metrics_sdk::PeriodicExportingMetricReaderFactory::Create(std::move(exporter), options); + + matlab::data::TypedArray processorid_mda = constructor_arguments[0]; + libmexclass::proxy::ID processorid = processorid_mda[0]; + auto reader = std::static_pointer_cast( + libmexclass::proxy::ProxyManager::getProxy(processorid))->getInstance(); auto p = metrics_sdk::MeterProviderFactory::Create(); auto *p_sdk = static_cast(p.get()); @@ -51,4 +52,20 @@ void MeterProviderProxy::getMeter(libmexclass::proxy::method::Context& context) } + +void MeterProviderProxy::addMetricReader(libmexclass::proxy::method::Context& context) { + /* + matlab::data::TypedArray processorid_mda = context.inputs[0]; + libmexclass::proxy::ID processorid = processorid_mda[0]; + + static_cast(*CppTracerProvider).AddProcessor( + std::static_pointer_cast( + libmexclass::proxy::ProxyManager::getProxy(processorid))->getInstance()); + */ + return; +} + + + + } // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/src/PeriodicExportingMetricReader.cpp b/sdk/metrics/src/PeriodicExportingMetricReader.cpp deleted file mode 100644 index de6d6f9..0000000 --- a/sdk/metrics/src/PeriodicExportingMetricReader.cpp +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright 2023 The MathWorks, Inc. - -#pragma once - -#include "opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReader.h" - - -namespace libmexclass::opentelemetry::sdk { -libmexclass::proxy::MakeResult PeriodicExportingMetricReaderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments){ - - libmexclass::proxy::MakeResult out; - - return out - -} - - -//std::unique_ptr PeriodicExportingMetricReaderProxy::getInstance() - - -//void PeriodicExportingMetricReaderProxy::getDefaultOptionValues(libmexclass::proxy::method::Context& context) - -} // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/src/PeriodicExportingMetricReaderProxy.cpp b/sdk/metrics/src/PeriodicExportingMetricReaderProxy.cpp new file mode 100644 index 0000000..4f0f3e6 --- /dev/null +++ b/sdk/metrics/src/PeriodicExportingMetricReaderProxy.cpp @@ -0,0 +1,59 @@ +// Copyright 2023 The MathWorks, Inc. + +#pragma once + +#include "opentelemetry-matlab/sdk/metrics/MetricExporterProxy.h" +#include "opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h" + +#include "libmexclass/proxy/ProxyManager.h" + + +namespace libmexclass::opentelemetry::sdk { + +PeriodicExportingMetricReaderProxy::PeriodicExportingMetricReaderProxy(std::shared_ptr exporter, + double interval, double timeout) + : MetricExporter(exporter) { + + if (interval > 0) { + CppOptions.export_interval_millis = std::chrono::milliseconds(static_cast(interval)); + } + if (timeout > 0) { + CppOptions.export_timeout_millis = std::chrono::milliseconds(static_cast(timeout)); + } + + REGISTER_METHOD(PeriodicExportingMetricReaderProxy, getDefaultOptionValues); +} + + +libmexclass::proxy::MakeResult PeriodicExportingMetricReaderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments){ + matlab::data::TypedArray exporterid_mda = constructor_arguments[0]; + libmexclass::proxy::ID exporterid = exporterid_mda[0]; + std::shared_ptr exporter = std::static_pointer_cast( + libmexclass::proxy::ProxyManager::getProxy(exporterid)); + matlab::data::TypedArray interval_mda = constructor_arguments[1]; + double interval = interval_mda[0]; + matlab::data::TypedArray timeout_mda = constructor_arguments[2]; + double timeout = timeout_mda[0]; + + return std::make_shared(exporter, interval, timeout); +} + + +std::unique_ptr PeriodicExportingMetricReaderProxy::getInstance(){ + return std::unique_ptr ( + metric_sdk::PeriodicExportingMetricReaderFactory::Create(std::move(MetricExporter->getInstance()), CppOptions)); +} + + +void PeriodicExportingMetricReaderProxy::getDefaultOptionValues(libmexclass::proxy::method::Context& context){ + metric_sdk::PeriodicExportingMetricReaderOptions options; + matlab::data::ArrayFactory factory; + auto interval_mda = factory.createScalar(static_cast( + options.export_interval_millis.count())); + auto timeout_mda = factory.createScalar(static_cast( + options.export_timeout_millis.count())); + context.outputs[0] = interval_mda; + context.outputs[1] = timeout_mda; +} + +} // namespace libmexclass::opentelemetry From 98bd3a6a7750c258abbbb21d00a0b2f750fde63e Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Thu, 28 Sep 2023 13:36:59 -0400 Subject: [PATCH 03/40] v2 --- CMakeLists.txt | 3 +- .../otlp/OtlpHttpMetricExporterProxy.h | 17 +++++++++++ .../otlp/src/OtlpHttpMetricExporterProxy.cpp | 28 +++++++++++++++++++ sdk/metrics/src/MeterProviderProxy.cpp | 10 +++++++ 4 files changed, 57 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2fac526..cb70f5f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -233,7 +233,8 @@ set(OPENTELEMETRY_PROXY_SOURCES ${COMMON_SDK_SOURCE_DIR}/resource.cpp) if(WITH_OTLP_HTTP) set(OPENTELEMETRY_PROXY_SOURCES ${OPENTELEMETRY_PROXY_SOURCES} - ${OTLP_EXPORTER_SOURCE_DIR}/OtlpHttpSpanExporterProxy.cpp) + ${OTLP_EXPORTER_SOURCE_DIR}/OtlpHttpSpanExporterProxy.cpp + ${OTLP_EXPORTER_SOURCE_DIR}/OtlpHttpMetricExporterProxy.cpp) endif() if(WITH_OTLP_GRPC) set(OPENTELEMETRY_PROXY_SOURCES ${OPENTELEMETRY_PROXY_SOURCES} diff --git a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h index 9f36f9a..0b74322 100644 --- a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h +++ b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h @@ -8,7 +8,11 @@ #include "libmexclass/proxy/method/Context.h" #include "opentelemetry/sdk/metrics/push_metric_exporter.h" +<<<<<<< Updated upstream #include "opentelemetry/exporters/otlp/otlp_http_exporter_options.h" +======= +#include "opentelemetry/exporters/otlp/otlp_http_metric_exporter_options.h" +>>>>>>> Stashed changes namespace metric_sdk = opentelemetry::sdk::metrics; namespace otlp_exporter = opentelemetry::exporter::otlp; @@ -16,8 +20,14 @@ namespace otlp_exporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::exporters { class OtlpHttpMetricExporterProxy: public libmexclass::opentelemetry::sdk::MetricExporterProxy { public: +<<<<<<< Updated upstream OtlpHttpMetricExporterProxy(otlp_exporter::OtlpHttpExporterOptions options) : CppOptions(options) { REGISTER_METHOD(OtlpHttpMetricExporterProxy, getDefaultOptionValues); +======= + OtlpHttpMetricExporterProxy(otlp_exporter::OtlpHttpMetricExporterOptions options) : CppOptions(options) { + REGISTER_METHOD(OtlpHttpMetricExporterProxy, getDefaultOptionValues); + REGISTER_METHOD(OtlpHttpMetricExporterProxy, test); +>>>>>>> Stashed changes } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); @@ -26,7 +36,14 @@ class OtlpHttpMetricExporterProxy: public libmexclass::opentelemetry::sdk::Metri void getDefaultOptionValues(libmexclass::proxy::method::Context& context); +<<<<<<< Updated upstream private: otlp_exporter::OtlpHttpExporterOptions CppOptions; +======= + void test(libmexclass::proxy::method::Context& context); + + private: + otlp_exporter::OtlpHttpMetricExporterOptions CppOptions; +>>>>>>> Stashed changes }; } // namespace libmexclass::opentelemetry diff --git a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp index 989348e..a157f5a 100644 --- a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp +++ b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp @@ -10,6 +10,10 @@ namespace otlp_exporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::exporters { libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { +<<<<<<< Updated upstream +======= + /* +>>>>>>> Stashed changes matlab::data::StringArray endpoint_mda = constructor_arguments[0]; std::string endpoint = static_cast(endpoint_mda[0]); matlab::data::StringArray dataformat_mda = constructor_arguments[1]; @@ -24,8 +28,16 @@ libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexcla size_t nheaders = header_mda.getNumberOfElements(); matlab::data::StringArray headernames_mda = constructor_arguments[5]; matlab::data::StringArray headervalues_mda = constructor_arguments[6]; +<<<<<<< Updated upstream otlp_exporter::OtlpHttpMetricExporterOptions options; +======= + */ + + otlp_exporter::OtlpHttpMetricExporterOptions options; + + /* +>>>>>>> Stashed changes if (!endpoint.empty()) { options.url = endpoint; } @@ -55,10 +67,19 @@ libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexcla options.http_headers.insert(std::pair{static_cast(headernames_mda[i]), static_cast(headervalues_mda[i])}); } +<<<<<<< Updated upstream return std::make_shared(options); } std::unique_ptr OtlpHttpMetricExporterProxy::getInstance() { +======= + */ + std::cout << "====================================\n"; + return std::make_shared(options); +} + +std::unique_ptr OtlpHttpMetricExporterProxy::getInstance() { +>>>>>>> Stashed changes return otlp_exporter::OtlpHttpMetricExporterFactory::Create(CppOptions); } @@ -90,4 +111,11 @@ void OtlpHttpMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::met context.outputs[2] = json_bytes_mapping_mda; context.outputs[3] = timeout_mda; } +<<<<<<< Updated upstream +======= + +void OtlpHttpMetricExporterProxy::test(libmexclass::proxy::method::Context& context){ + return; +} +>>>>>>> Stashed changes } // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index bea21b4..43695c6 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -11,12 +11,22 @@ namespace libmexclass::opentelemetry::sdk { libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { libmexclass::proxy::MakeResult out; +<<<<<<< Updated upstream matlab::data::TypedArray processorid_mda = constructor_arguments[0]; libmexclass::proxy::ID processorid = processorid_mda[0]; auto reader = std::static_pointer_cast( libmexclass::proxy::ProxyManager::getProxy(processorid))->getInstance(); +======= + + auto exporter = otlpexporter::OtlpHttpMetricExporterFactory::Create(); + // Initialize and set the periodic metrics reader + metrics_sdk::PeriodicExportingMetricReaderOptions options; + options.export_interval_millis = std::chrono::milliseconds(1000); + options.export_timeout_millis = std::chrono::milliseconds(500); + auto reader = metrics_sdk::PeriodicExportingMetricReaderFactory::Create(std::move(exporter), options); +>>>>>>> Stashed changes auto p = metrics_sdk::MeterProviderFactory::Create(); auto *p_sdk = static_cast(p.get()); p_sdk->AddMetricReader(std::move(reader)); From 4d8b9907a628872c7299ea1c9de1647c0ff10f0f Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Thu, 28 Sep 2023 13:40:14 -0400 Subject: [PATCH 04/40] v2 --- .../otlp/OtlpHttpMetricExporterProxy.h | 14 -------------- .../otlp/src/OtlpHttpMetricExporterProxy.cpp | 18 ------------------ 2 files changed, 32 deletions(-) diff --git a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h index 0b74322..9c99b17 100644 --- a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h +++ b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h @@ -8,11 +8,7 @@ #include "libmexclass/proxy/method/Context.h" #include "opentelemetry/sdk/metrics/push_metric_exporter.h" -<<<<<<< Updated upstream -#include "opentelemetry/exporters/otlp/otlp_http_exporter_options.h" -======= #include "opentelemetry/exporters/otlp/otlp_http_metric_exporter_options.h" ->>>>>>> Stashed changes namespace metric_sdk = opentelemetry::sdk::metrics; namespace otlp_exporter = opentelemetry::exporter::otlp; @@ -20,14 +16,9 @@ namespace otlp_exporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::exporters { class OtlpHttpMetricExporterProxy: public libmexclass::opentelemetry::sdk::MetricExporterProxy { public: -<<<<<<< Updated upstream - OtlpHttpMetricExporterProxy(otlp_exporter::OtlpHttpExporterOptions options) : CppOptions(options) { - REGISTER_METHOD(OtlpHttpMetricExporterProxy, getDefaultOptionValues); -======= OtlpHttpMetricExporterProxy(otlp_exporter::OtlpHttpMetricExporterOptions options) : CppOptions(options) { REGISTER_METHOD(OtlpHttpMetricExporterProxy, getDefaultOptionValues); REGISTER_METHOD(OtlpHttpMetricExporterProxy, test); ->>>>>>> Stashed changes } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); @@ -36,14 +27,9 @@ class OtlpHttpMetricExporterProxy: public libmexclass::opentelemetry::sdk::Metri void getDefaultOptionValues(libmexclass::proxy::method::Context& context); -<<<<<<< Updated upstream - private: - otlp_exporter::OtlpHttpExporterOptions CppOptions; -======= void test(libmexclass::proxy::method::Context& context); private: otlp_exporter::OtlpHttpMetricExporterOptions CppOptions; ->>>>>>> Stashed changes }; } // namespace libmexclass::opentelemetry diff --git a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp index a157f5a..906e153 100644 --- a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp +++ b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp @@ -10,10 +10,7 @@ namespace otlp_exporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::exporters { libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { -<<<<<<< Updated upstream -======= /* ->>>>>>> Stashed changes matlab::data::StringArray endpoint_mda = constructor_arguments[0]; std::string endpoint = static_cast(endpoint_mda[0]); matlab::data::StringArray dataformat_mda = constructor_arguments[1]; @@ -28,16 +25,11 @@ libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexcla size_t nheaders = header_mda.getNumberOfElements(); matlab::data::StringArray headernames_mda = constructor_arguments[5]; matlab::data::StringArray headervalues_mda = constructor_arguments[6]; -<<<<<<< Updated upstream - - otlp_exporter::OtlpHttpMetricExporterOptions options; -======= */ otlp_exporter::OtlpHttpMetricExporterOptions options; /* ->>>>>>> Stashed changes if (!endpoint.empty()) { options.url = endpoint; } @@ -67,19 +59,12 @@ libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexcla options.http_headers.insert(std::pair{static_cast(headernames_mda[i]), static_cast(headervalues_mda[i])}); } -<<<<<<< Updated upstream - return std::make_shared(options); -} - -std::unique_ptr OtlpHttpMetricExporterProxy::getInstance() { -======= */ std::cout << "====================================\n"; return std::make_shared(options); } std::unique_ptr OtlpHttpMetricExporterProxy::getInstance() { ->>>>>>> Stashed changes return otlp_exporter::OtlpHttpMetricExporterFactory::Create(CppOptions); } @@ -111,11 +96,8 @@ void OtlpHttpMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::met context.outputs[2] = json_bytes_mapping_mda; context.outputs[3] = timeout_mda; } -<<<<<<< Updated upstream -======= void OtlpHttpMetricExporterProxy::test(libmexclass::proxy::method::Context& context){ return; } ->>>>>>> Stashed changes } // namespace libmexclass::opentelemetry From 081f16e7e7303ef4a22eda91a5ebeb2929c2e0bb Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Thu, 28 Sep 2023 13:50:04 -0400 Subject: [PATCH 05/40] v2 --- sdk/metrics/src/MeterProviderProxy.cpp | 9 --------- 1 file changed, 9 deletions(-) diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index 43695c6..d577d7a 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -11,14 +11,6 @@ namespace libmexclass::opentelemetry::sdk { libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { libmexclass::proxy::MakeResult out; -<<<<<<< Updated upstream - - matlab::data::TypedArray processorid_mda = constructor_arguments[0]; - libmexclass::proxy::ID processorid = processorid_mda[0]; - auto reader = std::static_pointer_cast( - libmexclass::proxy::ProxyManager::getProxy(processorid))->getInstance(); - -======= auto exporter = otlpexporter::OtlpHttpMetricExporterFactory::Create(); // Initialize and set the periodic metrics reader @@ -26,7 +18,6 @@ libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy options.export_interval_millis = std::chrono::milliseconds(1000); options.export_timeout_millis = std::chrono::milliseconds(500); auto reader = metrics_sdk::PeriodicExportingMetricReaderFactory::Create(std::move(exporter), options); ->>>>>>> Stashed changes auto p = metrics_sdk::MeterProviderFactory::Create(); auto *p_sdk = static_cast(p.get()); p_sdk->AddMetricReader(std::move(reader)); From dd8e0e9ff92a0f43813bc6672bdfb354878156f1 Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Mon, 2 Oct 2023 13:00:35 -0400 Subject: [PATCH 06/40] v3 --- CMakeLists.txt | 20 ++-- OtelMatlabProxyFactory.cpp | 6 ++ .../+exporters/+otlp/OtlpGrpcMetricExporter.m | 30 +++--- .../+exporters/+otlp/OtlpHttpMetricExporter.m | 55 +++++------ .../otlp/OtlpGrpcMetricExporterProxy.h | 10 +- .../otlp/OtlpHttpMetricExporterProxy.h | 3 - ...er.cpp => OtlpGrpcMetricExporterProxy.cpp} | 26 +++++ .../otlp/src/OtlpHttpMetricExporterProxy.cpp | 35 +++++-- myoutput.json | 0 .../+sdk/+metrics/MeterProvider.m | 2 +- .../+metrics/PeriodicExportingMetricReader.m | 36 ++++--- sdk/metrics/src/MeterProviderProxy.cpp | 13 ++- test/tmetrics.m | 96 +++++++++++++++---- 13 files changed, 223 insertions(+), 109 deletions(-) rename exporters/otlp/src/{OtlpGrpcMetricExporter.cpp => OtlpGrpcMetricExporterProxy.cpp} (71%) create mode 100644 myoutput.json diff --git a/CMakeLists.txt b/CMakeLists.txt index cb70f5f..d9762eb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -232,13 +232,16 @@ set(OPENTELEMETRY_PROXY_SOURCES ${METRICS_SDK_SOURCE_DIR}/PeriodicExportingMetricReaderProxy.cpp ${COMMON_SDK_SOURCE_DIR}/resource.cpp) if(WITH_OTLP_HTTP) - set(OPENTELEMETRY_PROXY_SOURCES ${OPENTELEMETRY_PROXY_SOURCES} - ${OTLP_EXPORTER_SOURCE_DIR}/OtlpHttpSpanExporterProxy.cpp + set(OPENTELEMETRY_PROXY_SOURCES + ${OPENTELEMETRY_PROXY_SOURCES} + ${OTLP_EXPORTER_SOURCE_DIR}/OtlpHttpSpanExporterProxy.cpp ${OTLP_EXPORTER_SOURCE_DIR}/OtlpHttpMetricExporterProxy.cpp) endif() if(WITH_OTLP_GRPC) - set(OPENTELEMETRY_PROXY_SOURCES ${OPENTELEMETRY_PROXY_SOURCES} - ${OTLP_EXPORTER_SOURCE_DIR}/OtlpGrpcSpanExporterProxy.cpp) + set(OPENTELEMETRY_PROXY_SOURCES + ${OPENTELEMETRY_PROXY_SOURCES} + ${OTLP_EXPORTER_SOURCE_DIR}/OtlpGrpcSpanExporterProxy.cpp + ${OTLP_EXPORTER_SOURCE_DIR}/OtlpGrpcMetricExporterProxy.cpp) endif() libmexclass_client_add_proxy_library( @@ -391,11 +394,12 @@ set(COMMON_API_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/api/common/+openteleme set(TRACE_SDK_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/sdk/trace/+opentelemetry) set(METRICS_SDK_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/sdk/metrics/+opentelemetry) set(DEFAULT_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultSpanExporter.m) +set(DEFAULT_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m) set(OTLP_HTTP_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpSpanExporter.m) +set(OTLP_HTTP_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m) set(OTLP_GRPC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcSpanExporter.m) -set(DEFAULT_METRIC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m) -set(OTLP_HTTP_METRIC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m) -set(OTLP_GRPC_METRIC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m) +set(OTLP_GRPC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m) + set(OTLP_EXPORTERS_DIR +opentelemetry/+exporters/+otlp) @@ -410,11 +414,9 @@ install(FILES ${DEFAULT_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DI install(FILES ${DEFAULT_METRIC_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) if(WITH_OTLP_HTTP) install(FILES ${OTLP_HTTP_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) - install(FILES ${OTLP_HTTP_METRIC_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) endif() if(WITH_OTLP_GRPC) install(FILES ${OTLP_GRPC_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) - install(FILES ${OTLP_GRPC_METRIC_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) endif() # Install dependent runtime libraries diff --git a/OtelMatlabProxyFactory.cpp b/OtelMatlabProxyFactory.cpp index 925094d..5b3302c 100644 --- a/OtelMatlabProxyFactory.cpp +++ b/OtelMatlabProxyFactory.cpp @@ -23,11 +23,14 @@ #include "opentelemetry-matlab/sdk/trace/TraceIdRatioBasedSamplerProxy.h" #include "opentelemetry-matlab/sdk/trace/ParentBasedSamplerProxy.h" #include "opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h" +#include "opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h" #ifdef WITH_OTLP_HTTP #include "opentelemetry-matlab/exporters/otlp/OtlpHttpSpanExporterProxy.h" + #include "opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h" #endif #ifdef WITH_OTLP_GRPC #include "opentelemetry-matlab/exporters/otlp/OtlpGrpcSpanExporterProxy.h" + #include "opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h" #endif libmexclass::proxy::MakeResult @@ -57,12 +60,15 @@ OtelMatlabProxyFactory::make_proxy(const libmexclass::proxy::ClassName& class_na REGISTER_PROXY(libmexclass.opentelemetry.sdk.ParentBasedSamplerProxy, libmexclass::opentelemetry::sdk::ParentBasedSamplerProxy); REGISTER_PROXY(libmexclass.opentelemetry.sdk.MeterProviderProxy, libmexclass::opentelemetry::sdk::MeterProviderProxy); + REGISTER_PROXY(libmexclass.opentelemetry.sdk.PeriodicExportingMetricReaderProxy, libmexclass::opentelemetry::sdk::PeriodicExportingMetricReaderProxy); #ifdef WITH_OTLP_HTTP REGISTER_PROXY(libmexclass.opentelemetry.exporters.OtlpHttpSpanExporterProxy, libmexclass::opentelemetry::exporters::OtlpHttpSpanExporterProxy); + REGISTER_PROXY(libmexclass.opentelemetry.exporters.OtlpHttpMetricExporterProxy, libmexclass::opentelemetry::exporters::OtlpHttpMetricExporterProxy); #endif #ifdef WITH_OTLP_GRPC REGISTER_PROXY(libmexclass.opentelemetry.exporters.OtlpGrpcSpanExporterProxy, libmexclass::opentelemetry::exporters::OtlpGrpcSpanExporterProxy); + REGISTER_PROXY(libmexclass.opentelemetry.exporters.OtlpGrpcMetricExporterProxy, libmexclass::opentelemetry::exporters::OtlpGrpcMetricExporterProxy); #endif return nullptr; } diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m index 2f4a958..8595898 100644 --- a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m @@ -6,12 +6,13 @@ % Copyright 2023 The MathWorks, Inc. properties (SetAccess=immutable) - Endpoint (1,1) string % Export destination - UseCredentials (1,1) logical % Whether to use SSL credentials - CertificatePath (1,1) string % Path to .pem file for SSL encryption - CertificateString (1,1) string % In-memory string representation of .pem file for SSL encryption - Timeout (1,1) duration % Maximum time above which exports will abort - HttpHeaders (1,1) dictionary % Additional HTTP headers + Endpoint (1,1) string % Export destination + UseCredentials (1,1) logical % Whether to use SSL credentials + CertificatePath (1,1) string % Path to .pem file for SSL encryption + CertificateString (1,1) string % In-memory string representation of .pem file for SSL encryption + Timeout (1,1) duration % Maximum time above which exports will abort + HttpHeaders (1,1) dictionary % Additional HTTP headers + PreferredAggregationTemporality (1,1) string % Preferred Aggregation Temporality end methods @@ -44,7 +45,7 @@ end validnames = ["Endpoint", "UseCredentials ", "CertificatePath", ... - "CertificateString", "Timeout", "HttpHeaders"]; + "CertificateString", "Timeout", "HttpHeaders", "PreferredAggregationTemporality"]; % set default values to empty or negative endpoint = ""; usessl = false; @@ -53,6 +54,7 @@ timeout_millis = -1; headerkeys = string.empty(); headervalues = string.empty(); + temporality = ""; for i = 1:length(optionnames) namei = validatestring(optionnames{i}, validnames); valuei = optionvalues{i}; @@ -82,7 +84,7 @@ end timeout = valuei; timeout_millis = milliseconds(timeout); - else % HttpHeaders + elseif strcmp(namei, "HttpHeaders") % HttpHeaders if ~isa(valuei, "dictionary") error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:HttpHeadersNotDictionary", "HttpHeaders input must be a dictionary."); end @@ -92,16 +94,18 @@ if ~isstring(headervalues) error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:HttpHeadersNonStringValues", "HttpHeaders dictionary values must be strings.") end + elseif strcmp(namei, "PreferredAggregationTemporality") + temporality = validatestring(valuei, ["Cumulative", "Delta"]); end end obj = obj@opentelemetry.sdk.metrics.MetricExporter(... "libmexclass.opentelemetry.exporters.OtlpGrpcMetricExporterProxy", ... endpoint, usessl, certificatepath, certificatestring, ... - timeout_millis, headerkeys, headervalues); + timeout_millis, headerkeys, headervalues, temporality); % populate immutable properties - [defaultendpoint, defaultcertpath, defaultcertstring, defaultmillis] = ... + [defaultendpoint, defaultcertpath, defaultcertstring, defaultmillis, defaulttemporality] = ... getDefaultOptionValues(obj); if endpoint == "" % not specified, use default value obj.Endpoint = defaultendpoint; @@ -129,7 +133,11 @@ else obj.HttpHeaders = httpheaders; end - + if temporality == "" + obj.PreferredAggregationTemporality = defaulttemporality; + else + obj.PreferredAggregationTemporality = temporality; + end end end end diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m index 36c35cf..cffe5e8 100644 --- a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m @@ -6,45 +6,25 @@ % Copyright 2023 The MathWorks, Inc. properties (SetAccess=immutable) - Endpoint (1,1) string % Export destination - Format (1,1) string % Data format, JSON or binary - JsonBytesMapping (1,1) string % What to convert JSON bytes to - UseJsonName (1,1) logical % Whether to use JSON name of protobuf field to set the key of JSON - Timeout (1,1) duration % Maximum time above which exports will abort - HttpHeaders (1,1) dictionary % Additional HTTP headers + Endpoint (1,1) string % Export destination + Format (1,1) string % Data format, JSON or binary + JsonBytesMapping (1,1) string % What to convert JSON bytes to + UseJsonName (1,1) logical % Whether to use JSON name of protobuf field to set the key of JSON + Timeout (1,1) duration % Maximum time above which exports will abort + HttpHeaders (1,1) dictionary % Additional HTTP headers + PreferredAggregationTemporality (1,1) string % Preferred Aggregation Temporality end methods function obj = OtlpHttpMetricExporter(optionnames, optionvalues) - % OtlpHttpMetricExporter exports Metrics in OpenTelemetry Protocol format via HTTP. - % EXP = OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMetricEXPORTER - % creates an exporter that uses default configurations. - % - % EXP = - % OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMetricEXPORTER(PARAM1, - % VALUE1, PARAM2, VALUE2, ...) specifies optional parameter - % name/value pairs. Parameters are: - % "Endpoint" - Endpoint to export to - % "Format" - Data format: "JSON" (default) or "binary" - % "JsonBytesMapping" - What to convert JSON bytes to. Supported - % values are "hex", "hexId" (default), and - % "base64". Default "hexId" - % converts to base 64 except for IDs - % which are converted to hexadecimals. - % "UseJsonName" - Whether to use JSON name of protobuf - % field to set the key of JSON - % "Timeout" - Maximum time above which exports - % will abort - % "HTTPHeaders" - Additional HTTP Headers - % - % See also OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMetricEXPORTER + arguments (Repeating) optionnames (1,:) {mustBeTextScalar} optionvalues end validnames = ["Endpoint", "Format", "JsonBytesMapping", ... - "UseJsonName", "Timeout", "HttpHeaders"]; + "UseJsonName", "Timeout", "HttpHeaders", "PreferredAggregationTemporality"]; % set default values to empty or negative endpoint = ""; dataformat = ""; @@ -53,6 +33,7 @@ timeout_millis = -1; headerkeys = string.empty(); headervalues = string.empty(); + temporality = ""; for i = 1:length(optionnames) namei = validatestring(optionnames{i}, validnames); valuei = optionvalues{i}; @@ -70,13 +51,13 @@ error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:UseJsonNameNotScalarLogical", "UseJsonName must be a scalar logical.") end usejsonname = logical(valuei); - elseif strcmp(namei, "Timeout") + elseif strcmp(namei, "Timeout") if ~(isduration(valuei) && isscalar(valuei)) error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:TimeoutNotScalarDuration", "Timeout must be a scalar duration."); end timeout = valuei; timeout_millis = milliseconds(timeout); - else % HttpHeaders + elseif strcmp(namei, "HttpHeaders") if ~isa(valuei, "dictionary") error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:HttpHeadersNotDictionary", "HttpHeaders input must be a dictionary."); end @@ -86,18 +67,21 @@ if ~isstring(headervalues) error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:HttpHeadersNonStringValues", "HttpHeaders dictionary values must be strings.") end + elseif strcmp(namei, "PreferredAggregationTemporality") + temporality = validatestring(valuei, ["Cumulative", "Delta"]); end + end obj = obj@opentelemetry.sdk.metrics.MetricExporter(... "libmexclass.opentelemetry.exporters.OtlpHttpMetricExporterProxy", ... endpoint, dataformat, jsonbytesmapping, usejsonname, ... - timeout_millis, headerkeys, headervalues); + timeout_millis, headerkeys, headervalues, temporality); % populate immutable properties if endpoint == "" || dataformat == "" || jsonbytesmapping == "" || ... timeout_millis < 0 - [defaultendpoint, defaultformat, defaultmapping, defaultmillis] = ... + [defaultendpoint, defaultformat, defaultmapping, defaultmillis, defaulttemporality] = ... getDefaultOptionValues(obj); end if endpoint == "" % not specified, use default value @@ -126,6 +110,11 @@ else obj.HttpHeaders = httpheaders; end + if temporality == "" + obj.PreferredAggregationTemporality = defaulttemporality; + else + obj.PreferredAggregationTemporality = temporality; + end end end end diff --git a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h index 757de20..e372672 100644 --- a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h +++ b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h @@ -8,25 +8,25 @@ #include "libmexclass/proxy/method/Context.h" #include "opentelemetry/sdk/metrics/push_metric_exporter.h" -#include "opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h" +#include "opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_options.h" -namespace metric_sdk = opentelemetry::sdk::metric; +namespace metric_sdk = opentelemetry::sdk::metrics; namespace otlp_exporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::exporters { class OtlpGrpcMetricExporterProxy: public libmexclass::opentelemetry::sdk::MetricExporterProxy { public: - OtlpGrpcMetricExporterProxy(otlp_exporter::OtlpGrpcExporterOptions options) : CppOptions(options) { + OtlpGrpcMetricExporterProxy(otlp_exporter::OtlpGrpcMetricExporterOptions options) : CppOptions(options) { REGISTER_METHOD(OtlpGrpcMetricExporterProxy, getDefaultOptionValues); } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); - std::unique_ptr getInstance() override; + std::unique_ptr getInstance() override; void getDefaultOptionValues(libmexclass::proxy::method::Context& context); private: - otlp_exporter::OtlpGrpcExporterOptions CppOptions; + otlp_exporter::OtlpGrpcMetricExporterOptions CppOptions; }; } // namespace libmexclass::opentelemetry diff --git a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h index 9c99b17..2dc929b 100644 --- a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h +++ b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h @@ -18,7 +18,6 @@ class OtlpHttpMetricExporterProxy: public libmexclass::opentelemetry::sdk::Metri public: OtlpHttpMetricExporterProxy(otlp_exporter::OtlpHttpMetricExporterOptions options) : CppOptions(options) { REGISTER_METHOD(OtlpHttpMetricExporterProxy, getDefaultOptionValues); - REGISTER_METHOD(OtlpHttpMetricExporterProxy, test); } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); @@ -27,8 +26,6 @@ class OtlpHttpMetricExporterProxy: public libmexclass::opentelemetry::sdk::Metri void getDefaultOptionValues(libmexclass::proxy::method::Context& context); - void test(libmexclass::proxy::method::Context& context); - private: otlp_exporter::OtlpHttpMetricExporterOptions CppOptions; }; diff --git a/exporters/otlp/src/OtlpGrpcMetricExporter.cpp b/exporters/otlp/src/OtlpGrpcMetricExporterProxy.cpp similarity index 71% rename from exporters/otlp/src/OtlpGrpcMetricExporter.cpp rename to exporters/otlp/src/OtlpGrpcMetricExporterProxy.cpp index 17474f2..0e0749a 100644 --- a/exporters/otlp/src/OtlpGrpcMetricExporter.cpp +++ b/exporters/otlp/src/OtlpGrpcMetricExporterProxy.cpp @@ -24,6 +24,8 @@ libmexclass::proxy::MakeResult OtlpGrpcMetricExporterProxy::make(const libmexcla size_t nheaders = header_mda.getNumberOfElements(); matlab::data::StringArray headernames_mda = constructor_arguments[5]; matlab::data::StringArray headervalues_mda = constructor_arguments[6]; + matlab::data::StringArray temporality_mda = constructor_arguments[7]; + std::string temporality = static_cast(temporality_mda[0]); otlp_exporter::OtlpGrpcMetricExporterOptions options; if (!endpoint.empty()) { @@ -46,6 +48,13 @@ libmexclass::proxy::MakeResult OtlpGrpcMetricExporterProxy::make(const libmexcla options.metadata.insert(std::pair{static_cast(headernames_mda[i]), static_cast(headervalues_mda[i])}); } + // Preferred Aggregation Temporality + if (temporality.compare("Cumulative") == 0) { + options.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kCumulative; + } + else if (temporality.compare("Delta") == 0) { + options.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kDelta; + } return std::make_shared(options); } @@ -61,9 +70,26 @@ void OtlpGrpcMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::met auto certstring_mda = factory.createScalar(options.ssl_credentials_cacert_as_string); auto timeout_millis = std::chrono::duration_cast(options.timeout); auto timeout_mda = factory.createScalar(static_cast(timeout_millis.count())); + std::string aggregation_temporality; + // Preferred Aggregation Temporality + if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kCumulative){ + aggregation_temporality = "Cumulative"; + } + else if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kDelta){ + aggregation_temporality = "Delta"; + } + else if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kLowMemory){ + aggregation_temporality = "LowMemory"; + } + else { + aggregation_temporality = "Unspecified"; + } + auto aggregation_temporality_mda = factory.createScalar(aggregation_temporality); context.outputs[0] = endpoint_mda; context.outputs[1] = certpath_mda; context.outputs[2] = certstring_mda; context.outputs[3] = timeout_mda; + context.outputs[4] = aggregation_temporality_mda; + } } // namespace libmexclass::opentelemetry diff --git a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp index 906e153..e1636b5 100644 --- a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp +++ b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp @@ -10,7 +10,6 @@ namespace otlp_exporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::exporters { libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { - /* matlab::data::StringArray endpoint_mda = constructor_arguments[0]; std::string endpoint = static_cast(endpoint_mda[0]); matlab::data::StringArray dataformat_mda = constructor_arguments[1]; @@ -25,11 +24,11 @@ libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexcla size_t nheaders = header_mda.getNumberOfElements(); matlab::data::StringArray headernames_mda = constructor_arguments[5]; matlab::data::StringArray headervalues_mda = constructor_arguments[6]; - */ + matlab::data::StringArray temporality_mda = constructor_arguments[7]; + std::string temporality = static_cast(temporality_mda[0]); otlp_exporter::OtlpHttpMetricExporterOptions options; - /* if (!endpoint.empty()) { options.url = endpoint; } @@ -59,8 +58,13 @@ libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexcla options.http_headers.insert(std::pair{static_cast(headernames_mda[i]), static_cast(headervalues_mda[i])}); } - */ - std::cout << "====================================\n"; + // Preferred Aggregation Temporality + if (temporality.compare("Cumulative") == 0) { + options.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kCumulative; + } + else if (temporality.compare("Delta") == 0) { + options.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kDelta; + } return std::make_shared(options); } @@ -72,7 +76,7 @@ void OtlpHttpMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::met otlp_exporter::OtlpHttpMetricExporterOptions options; matlab::data::ArrayFactory factory; auto endpoint_mda = factory.createScalar(options.url); - std::string dataformat, json_bytes_mapping; + std::string dataformat, json_bytes_mapping, aggregation_temporality; // dataformat if (options.content_type == otlp_exporter::HttpRequestContentType::kJson) { dataformat = "JSON"; @@ -87,17 +91,30 @@ void OtlpHttpMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::met } else { // kBase64 json_bytes_mapping = "base64"; } + // Preferred Aggregation Temporality + if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kCumulative){ + aggregation_temporality = "Cumulative"; + } + else if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kDelta){ + aggregation_temporality = "Delta"; + } + else if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kLowMemory){ + aggregation_temporality = "LowMemory"; + } + else { + aggregation_temporality = "Unspecified"; + } + auto dataformat_mda = factory.createScalar(dataformat); auto json_bytes_mapping_mda = factory.createScalar(json_bytes_mapping); auto timeout_millis = std::chrono::duration_cast(options.timeout); auto timeout_mda = factory.createScalar(static_cast(timeout_millis.count())); + auto aggregation_temporality_mda = factory.createScalar(aggregation_temporality); context.outputs[0] = endpoint_mda; context.outputs[1] = dataformat_mda; context.outputs[2] = json_bytes_mapping_mda; context.outputs[3] = timeout_mda; + context.outputs[4] = aggregation_temporality_mda; } -void OtlpHttpMetricExporterProxy::test(libmexclass::proxy::method::Context& context){ - return; -} } // namespace libmexclass::opentelemetry diff --git a/myoutput.json b/myoutput.json new file mode 100644 index 0000000..e69de29 diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index ff41370..4639b99 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -37,7 +37,7 @@ obj.Proxy = libmexclass.proxy.Proxy("Name", ... "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... - "ConstructorArguments", {}); + "ConstructorArguments", {reader.Proxy.ID}); end function meter = getMeter(obj, mtname, mtversion, mtschema) diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m index 6fe89bd..d79c7bb 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m @@ -8,12 +8,12 @@ end properties (SetAccess=immutable) - MetircExporter % Metric exporter object responsible for exporting telemetry data to an OpenTelemetry Collector or a compatible backend. - Interval (1,1) double % Maximum queue size. After queue size is reached, spans are dropped. - Timeout (1,1) double + MetricExporter % Metric exporter object responsible for exporting telemetry data to an OpenTelemetry Collector or a compatible backend. + Interval (1,1) duration + Timeout (1,1) duration end - methods (Access=?opentelemetry.sdk.metrics.MeterProvider) + methods %(Access=?opentelemetry.sdk.metrics.MeterProvider) function obj = PeriodicExportingMetricReader(metricexporter, optionnames, optionvalues) arguments @@ -24,21 +24,20 @@ optionnames (1,:) {mustBeTextScalar} optionvalues end - validnames = ["Interval", "Timeout"]; % set default values - intervalmillis = 60; - timeoutmillis = 30; + intervalmillis = -1; + timeoutmillis = -1; for i = 1:length(optionnames) namei = validatestring(optionnames{i}, validnames); valuei = optionvalues{i}; if strcmp(namei, "Interval") - if ~isnumeric(valuei) || ~isscalar(valuei) || valuei <= 0 || ... + if ~isduration(valuei) || ~isscalar(valuei) || valuei <= 0 || ... round(valuei) ~= valuei error("opentelemetry:sdk:metrics::PeriodicExportingMetricReader::InvalidInterval", ... - "Interval must be a scalar positive integer."); + "Interval must be a positive duration integer."); end - intervalmillis = double(valuei); + intervalmillis = milliseconds(valuei); elseif strcmp(namei, "Timeout") if ~isduration(valuei) || ~isscalar(valuei) || valuei <= 0 error("opentelemetry:sdk:metrics:PeriodicExportingMetricReader:InvalidTimeout", ... @@ -49,10 +48,21 @@ end obj.MetricExporter = metricexporter; - obj.Interval = intervalmillis; - obj.Timeout = timeoutmillis; obj.Proxy = libmexclass.proxy.Proxy("Name", "libmexclass.opentelemetry.sdk.PeriodicExportingMetricReaderProxy" , ... - "ConstructorArguments", [metricexporter.Proxy.ID, Interval, Timeout]); + "ConstructorArguments", {metricexporter.Proxy.ID, intervalmillis, timeoutmillis}); + + [defaultinterval, defaulttimeout] = obj.Proxy.getDefaultOptionValues(); + if intervalmillis <= 0 + obj.Interval = milliseconds(defaultinterval); + else + obj.Interval = milliseconds(intervalmillis); + end + if timeoutmillis <= 0 + obj.Timeout = milliseconds(defaulttimeout); + else + obj.Timeout = milliseconds(timeoutmillis); + end + end end diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index d577d7a..66a2267 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -11,13 +11,12 @@ namespace libmexclass::opentelemetry::sdk { libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { libmexclass::proxy::MakeResult out; - - auto exporter = otlpexporter::OtlpHttpMetricExporterFactory::Create(); - // Initialize and set the periodic metrics reader - metrics_sdk::PeriodicExportingMetricReaderOptions options; - options.export_interval_millis = std::chrono::milliseconds(1000); - options.export_timeout_millis = std::chrono::milliseconds(500); - auto reader = metrics_sdk::PeriodicExportingMetricReaderFactory::Create(std::move(exporter), options); + + matlab::data::TypedArray readerid_mda = constructor_arguments[0]; + libmexclass::proxy::ID readerid = readerid_mda[0]; + + auto reader = std::static_pointer_cast( + libmexclass::proxy::ProxyManager::getProxy(readerid))->getInstance(); auto p = metrics_sdk::MeterProviderFactory::Create(); auto *p_sdk = static_cast(p.get()); p_sdk->AddMetricReader(std::move(reader)); diff --git a/test/tmetrics.m b/test/tmetrics.m index c452504..da7cc92 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -37,13 +37,55 @@ function teardown(testCase) methods (Test) + function testDefaultExporter(testCase) + exporter = opentelemetry.exporters.otlp.defaultMetricExporter; + verifyEqual(testCase, string(class(exporter)), "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); + verifyEqual(testCase, string(exporter.Endpoint), "http://localhost:4318/v1/metrics"); + verifyEqual(testCase, exporter.Timeout, seconds(10)); + verifyEqual(testCase, string(exporter.PreferredAggregationTemporality), "Cumulative"); + end + + + function testExporterBasic(testCase) + timeout = seconds(5); + temporality = "Delta"; + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter("Timeout", timeout, ... + "PreferredAggregationTemporality", temporality); + verifyEqual(testCase, exporter.Timeout, timeout); + verifyEqual(testCase, string(exporter.PreferredAggregationTemporality), temporality); + end + + + function testDefaultReader(testCase) + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(); + verifyEqual(testCase, string(class(reader.MetricExporter)), "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); + verifyEqual(testCase, reader.Interval, seconds(60)); + verifyEqual(testCase, reader.Timeout, seconds(30)); + end + + + function testReaderBasic(testCase) + exporter = opentelemetry.exporters.otlp.defaultMetricExporter; + interval = seconds(1); + timeout = seconds(0.5); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", interval, ... + "Timeout", timeout); + verifyEqual(testCase, reader.Interval, interval); + verifyEqual(testCase, reader.Timeout, timeout); + end + + function testCounterBasic(testCase) % test names and added value in Counter metername = "foo"; countername = "bar"; - - p = opentelemetry.sdk.metrics.MeterProvider(); + + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader); mt = p.getMeter(metername); ct = mt.createCounter(countername); @@ -60,7 +102,7 @@ function testCounterBasic(testCase) ct.add(val); % wait for default collector response time (60s) - pause(70); + pause(2.5); % fetch result results = readJsonResults(testCase); @@ -85,7 +127,10 @@ function testCounterAddAttributes(testCase) metername = "foo"; countername = "bar"; - p = opentelemetry.sdk.metrics.MeterProvider(); + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader); mt = p.getMeter(metername); ct = mt.createCounter(countername); @@ -100,8 +145,8 @@ function testCounterAddAttributes(testCase) ct.add(vals(2),dict); ct.add(vals(3),dict_keys(1),dict_vals(1),dict_keys(2),dict_vals(2)); - % wait for default collector response time (60s) - pause(70); + % wait for collector response + pause(2.5); % fetch result results = readJsonResults(testCase); @@ -135,13 +180,16 @@ function testCounterAddNegative(testCase) metername = "foo"; countername = "bar"; - p = opentelemetry.sdk.metrics.MeterProvider(); + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader); mt = p.getMeter(metername); ct = mt.createCounter(countername); % add negative value to counter ct.add(-1); - pause(70); + pause(2.5); % fetch results results = readJsonResults(testCase); @@ -160,7 +208,10 @@ function testUpDownCounterBasic(testCase) metername = "foo"; countername = "bar"; - p = opentelemetry.sdk.metrics.MeterProvider(); + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader); mt = p.getMeter(metername); ct = mt.createUpDownCounter(countername); @@ -176,8 +227,8 @@ function testUpDownCounterBasic(testCase) % add value and attributes ct.add(val); - % wait for default collector response time (60s) - pause(70); + % wait for collector response time (2s) + pause(5); % fetch result results = readJsonResults(testCase); @@ -202,7 +253,10 @@ function testUpDownCounterAddAttributes(testCase) metername = "foo"; countername = "bar"; - p = opentelemetry.sdk.metrics.MeterProvider(); + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader); mt = p.getMeter(metername); ct = mt.createUpDownCounter(countername); @@ -217,8 +271,8 @@ function testUpDownCounterAddAttributes(testCase) ct.add(vals(2),dict); ct.add(vals(3),dict_keys(1),dict_vals(1),dict_keys(2),dict_vals(2)); - % wait for default collector response time (60s) - pause(70); + % wait for collector response + pause(5); % fetch result results = readJsonResults(testCase); @@ -252,7 +306,10 @@ function testHistogramBasic(testCase) metername = "foo"; histname = "bar"; - p = opentelemetry.sdk.metrics.MeterProvider(); + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader); mt = p.getMeter(metername); hist = mt.createHistogram(histname); @@ -269,7 +326,7 @@ function testHistogramBasic(testCase) hist.record(val); % wait for collector response - pause(75); + pause(10); % fetch results results = readJsonResults(testCase); @@ -307,7 +364,10 @@ function testHistogramRecordAttributes(testCase) metername = "foo"; histname = "bar"; - p = opentelemetry.sdk.metrics.MeterProvider(); + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader); mt = p.getMeter(metername); hist = mt.createHistogram(histname); @@ -323,7 +383,7 @@ function testHistogramRecordAttributes(testCase) hist.record(vals(3),dict_keys(1),dict_vals(1),dict_keys(2),dict_vals(2)); % wait for collector response - pause(75); + pause(10); % fetch results results = readJsonResults(testCase); From cc9cf8fa3963381e8badd02c6198b6cb6077f9a8 Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Mon, 2 Oct 2023 13:21:51 -0400 Subject: [PATCH 07/40] v4 add counter test for aggregation temporality as delta --- test/tmetrics.m | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/test/tmetrics.m b/test/tmetrics.m index da7cc92..1401cc6 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -120,6 +120,42 @@ function testCounterBasic(testCase) end + function testCounterDelta(testCase) + metername = "foo"; + countername = "bar"; + + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... + "PreferredAggregationTemporality", "Delta"); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader); + mt = p.getMeter(metername); + ct = mt.createCounter(countername); + + % verify MATLAB object properties + verifyEqual(testCase, mt.Name, metername); + verifyEqual(testCase, mt.Version, ""); + verifyEqual(testCase, mt.Schema, ""); + verifyEqual(testCase, ct.Name, countername); + + % create testing value + vals = [10, 20]; + + % add value and attributes + ct.add(vals(1)); + pause(3); + ct.add(vals(2)); + + % fetch results + pause(2.5); + results = readJsonResults(testCase); + dp1 = results{1}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; + dp2 = results{2}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; + + % verify counter value + verifyEqual(testCase, dp1.asDouble, vals(1)); + verifyEqual(testCase, dp2.asDouble, vals(2)); + end function testCounterAddAttributes(testCase) % test names, added value and attributes in Counter From 883f261f5dc6134711542467d6401d3c2cb6c376 Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Mon, 2 Oct 2023 13:52:24 -0400 Subject: [PATCH 08/40] v5 fix cmakelist --- CMakeLists.txt | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index d9762eb..23b7ec3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -393,12 +393,15 @@ set(BAGGAGE_API_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/api/baggage/+opentele set(COMMON_API_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/api/common/+opentelemetry) set(TRACE_SDK_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/sdk/trace/+opentelemetry) set(METRICS_SDK_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/sdk/metrics/+opentelemetry) -set(DEFAULT_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultSpanExporter.m) -set(DEFAULT_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m) -set(OTLP_HTTP_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpSpanExporter.m) -set(OTLP_HTTP_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m) -set(OTLP_GRPC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcSpanExporter.m) -set(OTLP_GRPC_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m) +set(DEFAULT_EXPORTER_MATLAB_SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultSpanExporter.m + ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m) +set(OTLP_HTTP_EXPORTER_MATLAB_SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpSpanExporter.m + ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m) +set(OTLP_GRPC_EXPORTER_MATLAB_SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcSpanExporter.m + ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m) set(OTLP_EXPORTERS_DIR +opentelemetry/+exporters/+otlp) From 137fed8c49ca2cbdba63a6004f4d1893822dcdbf Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Tue, 3 Oct 2023 10:02:28 -0400 Subject: [PATCH 09/40] v6 clear meter provider before read json results (which terminates collector) in tmetrics. --- CMakeLists.txt | 1 - test/tmetrics.m | 10 +++++++++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 23b7ec3..97bdb3a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -414,7 +414,6 @@ install(DIRECTORY ${COMMON_API_MATLAB_SOURCES} DESTINATION .) install(DIRECTORY ${TRACE_SDK_MATLAB_SOURCES} DESTINATION .) install(DIRECTORY ${METRICS_SDK_MATLAB_SOURCES} DESTINATION .) install(FILES ${DEFAULT_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) -install(FILES ${DEFAULT_METRIC_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) if(WITH_OTLP_HTTP) install(FILES ${OTLP_HTTP_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) endif() diff --git a/test/tmetrics.m b/test/tmetrics.m index 1401cc6..3a4cfb3 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -101,10 +101,11 @@ function testCounterBasic(testCase) % add value and attributes ct.add(val); - % wait for default collector response time (60s) + % wait for collector response pause(2.5); % fetch result + clear p; results = readJsonResults(testCase); results = results{1}; @@ -148,6 +149,7 @@ function testCounterDelta(testCase) % fetch results pause(2.5); + clear p; results = readJsonResults(testCase); dp1 = results{1}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; dp2 = results{2}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -185,6 +187,7 @@ function testCounterAddAttributes(testCase) pause(2.5); % fetch result + clear p; results = readJsonResults(testCase); results = results{1}; @@ -228,6 +231,7 @@ function testCounterAddNegative(testCase) pause(2.5); % fetch results + clear p; results = readJsonResults(testCase); results = results{1}; dp = results.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -267,6 +271,7 @@ function testUpDownCounterBasic(testCase) pause(5); % fetch result + clear p; results = readJsonResults(testCase); results = results{1}; @@ -311,6 +316,7 @@ function testUpDownCounterAddAttributes(testCase) pause(5); % fetch result + clear p; results = readJsonResults(testCase); results = results{1}; @@ -365,6 +371,7 @@ function testHistogramBasic(testCase) pause(10); % fetch results + clear p; results = readJsonResults(testCase); results = results{1}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; @@ -422,6 +429,7 @@ function testHistogramRecordAttributes(testCase) pause(10); % fetch results + clear p; results = readJsonResults(testCase); results = results{1}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; From 1b833dea7635189becf32400e36e1f767a617f04 Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Tue, 3 Oct 2023 11:02:44 -0400 Subject: [PATCH 10/40] v7 fix indexing in tmetrics add histogram test with delta temporality --- test/tmetrics.m | 71 +++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 57 insertions(+), 14 deletions(-) diff --git a/test/tmetrics.m b/test/tmetrics.m index 3a4cfb3..624e0e9 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -107,7 +107,7 @@ function testCounterBasic(testCase) % fetch result clear p; results = readJsonResults(testCase); - results = results{1}; + results = results{end}; % verify meter and counter names verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.metrics.name), countername); @@ -189,7 +189,7 @@ function testCounterAddAttributes(testCase) % fetch result clear p; results = readJsonResults(testCase); - results = results{1}; + results = results{end}; % verify meter and counter names verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.metrics.name), countername); @@ -233,7 +233,7 @@ function testCounterAddNegative(testCase) % fetch results clear p; results = readJsonResults(testCase); - results = results{1}; + results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; % verify that the counter value is still 0 @@ -273,7 +273,7 @@ function testUpDownCounterBasic(testCase) % fetch result clear p; results = readJsonResults(testCase); - results = results{1}; + results = results{end}; % verify meter and counter names verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.metrics.name), countername); @@ -318,13 +318,7 @@ function testUpDownCounterAddAttributes(testCase) % fetch result clear p; results = readJsonResults(testCase); - results = results{1}; - - % verify meter and counter names - verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.metrics.name), countername); - verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.scope.name), metername); - - % fetch datapoint + results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; % verify counter value @@ -373,7 +367,7 @@ function testHistogramBasic(testCase) % fetch results clear p; results = readJsonResults(testCase); - results = results{1}; + results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; bounds = dp.explicitBounds; counts = dp.bucketCounts; @@ -403,7 +397,6 @@ function testHistogramBasic(testCase) function testHistogramRecordAttributes(testCase) % test recorded values and attributes in histogram - metername = "foo"; histname = "bar"; @@ -431,7 +424,7 @@ function testHistogramRecordAttributes(testCase) % fetch results clear p; results = readJsonResults(testCase); - results = results{1}; + results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; bounds = dp.explicitBounds; counts = dp.bucketCounts; @@ -460,7 +453,57 @@ function testHistogramRecordAttributes(testCase) verifyEqual(testCase, str2double(counts{i}), expect_count); end verifyEqual(testCase, str2double(counts{len}), sum(vals>bounds(len-1))); + end + + + function testHistogramDelta(testCase) + metername = "foo"; + histname = "bar"; + + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... + "PreferredAggregationTemporality", "Delta"); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader); + mt = p.getMeter(metername); + hist = mt.createHistogram(histname); + + % record value and attributes + rawvals = [1 6]; + vals = {[rawvals(1)], [rawvals(2)]}; + hist.record(rawvals(1)); + pause(2.5); + hist.record(rawvals(2)); + % wait for collector response + pause(2.5); + + % fetch results + clear p; + results = readJsonResults(testCase); + rsize = size(results); + for i = 1:rsize(2) + dp = results{i}.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; + bounds = dp.explicitBounds; + counts = dp.bucketCounts; + + currentvals = vals{i}; + % verify statistics + verifyEqual(testCase, dp.min, min(currentvals)); + verifyEqual(testCase, dp.max, max(currentvals)); + verifyEqual(testCase, dp.sum, sum(currentvals)); + + % verify count in bucket + len = length(counts); + verifyEqual(testCase, str2double(counts{1}), sum(currentvals<=bounds(1))); + for j = 2:(len-1) + lower = bounds(j-1); + upper = bounds(j); + expect_count = sum(currentvals>lower & currentvals<=upper); + verifyEqual(testCase, str2double(counts{j}), expect_count); + end + verifyEqual(testCase, str2double(counts{len}), sum(currentvals>bounds(len-1))); + end end end From 6380ae12207c0fd40884493ed9e444efa270128c Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Wed, 4 Oct 2023 13:43:07 -0400 Subject: [PATCH 11/40] v8: addMetricReader implemented addMetricReader; add test for addMetricReader --- .../+sdk/+metrics/MeterProvider.m | 12 +++++++ sdk/metrics/src/MeterProviderProxy.cpp | 14 ++++----- test/tmetrics.m | 31 ++++++++++++++++++- 3 files changed, 48 insertions(+), 9 deletions(-) diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 4639b99..09b32f0 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -6,6 +6,9 @@ properties (Access=private) Proxy + end + + properties (Access=public) MetricReader end @@ -38,6 +41,7 @@ obj.Proxy = libmexclass.proxy.Proxy("Name", ... "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... "ConstructorArguments", {reader.Proxy.ID}); + obj.MetricReader = reader; end function meter = getMeter(obj, mtname, mtversion, mtschema) @@ -59,6 +63,14 @@ meter = opentelemetry.metrics.Meter(Meterproxy, mtname, mtversion, mtschema); end + function addMetricReader(obj, reader) + arguments + obj + reader (1,1) {mustBeA(reader, "opentelemetry.sdk.metrics.PeriodicExportingMetricReader")} + end + obj.Proxy.addMetricReader(reader.Proxy.ID); + obj.MetricReader = [obj.MetricReader, reader]; + end function success = shutdown(obj) if ~obj.isShutdown diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index 66a2267..1fa9587 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -54,14 +54,12 @@ void MeterProviderProxy::getMeter(libmexclass::proxy::method::Context& context) void MeterProviderProxy::addMetricReader(libmexclass::proxy::method::Context& context) { - /* - matlab::data::TypedArray processorid_mda = context.inputs[0]; - libmexclass::proxy::ID processorid = processorid_mda[0]; - - static_cast(*CppTracerProvider).AddProcessor( - std::static_pointer_cast( - libmexclass::proxy::ProxyManager::getProxy(processorid))->getInstance()); - */ + matlab::data::TypedArray readerid_mda = context.inputs[0]; + libmexclass::proxy::ID readerid = readerid_mda[0]; + + static_cast(*CppMeterProvider).AddMetricReader( + std::static_pointer_cast( + libmexclass::proxy::ProxyManager::getProxy(readerid))->getInstance()); return; } diff --git a/test/tmetrics.m b/test/tmetrics.m index 624e0e9..989fed3 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -75,10 +75,39 @@ function testReaderBasic(testCase) verifyEqual(testCase, reader.Timeout, timeout); end + + function testAddMetricReader(testCase) + metername = "foo"; + countername = "bar"; + exporter1 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter("PreferredAggregationTemporality", "Delta"); + exporter2 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter("PreferredAggregationTemporality", "Delta"); + reader1 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter1, ..., + "Interval", seconds(2), ... + "Timeout", seconds(1)); + reader2 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter2, ..., + "Interval", seconds(2), ... + "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader1); + p.addMetricReader(reader2) + mt = p.getMeter(metername); + ct = mt.createCounter(countername); + + % verify if the provider has two metric readers + reader_size = size(p.MetricReader); + verifyEqual(testCase,reader_size(2), 2); + + % verify if the provider has two exported instances + ct.add(1); + pause(2.5); + clear p; + results = readJsonResults(testCase); + result_size = size(results); + verifyEqual(testCase,result_size(2), 2); + end + function testCounterBasic(testCase) % test names and added value in Counter - metername = "foo"; countername = "bar"; From 300445cf858c19e6daf1840f96f8b36bfefbb595 Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Wed, 4 Oct 2023 15:36:05 -0400 Subject: [PATCH 12/40] v9: update comments update comments for metric exporters remove json output file --- .../+exporters/+otlp/OtlpGrpcMetricExporter.m | 13 +++++---- .../+exporters/+otlp/OtlpHttpMetricExporter.m | 28 +++++++++++++++++-- .../+exporters/+otlp/defaultMetricExporter.m | 2 +- myoutput.json | 0 .../+sdk/+metrics/MeterProvider.m | 4 ++- test/tmetrics.m | 21 +++++++------- 6 files changed, 49 insertions(+), 19 deletions(-) delete mode 100644 myoutput.json diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m index 8595898..edc7078 100644 --- a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m @@ -1,5 +1,5 @@ classdef OtlpGrpcMetricExporter < opentelemetry.sdk.metrics.MetricExporter -% OtlpGrpcMetricExporter exports Metrics in OpenTelemetry Protocol format via +% OtlpGrpcMetricExporter exports metrics in OpenTelemetry Protocol format via % gRPC. By default, it exports to the default address of the OpenTelemetry % Collector. @@ -17,12 +17,12 @@ methods function obj = OtlpGrpcMetricExporter(optionnames, optionvalues) - % OtlpGrpcMetricExporter exports Metrics in OpenTelemetry Protocol format via gRPC. - % EXP = OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMetricEXPORTER + % OtlpGrpcMetricExporter exports metrics in OpenTelemetry Protocol format via gRPC. + % EXP = OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMETRICEXPORTER % creates an exporter that uses default configurations. % % EXP = - % OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMetricEXPORTER(PARAM1, + % OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMETRICEXPORTER(PARAM1, % VALUE1, PARAM2, VALUE2, ...) specifies optional parameter % name/value pairs. Parameters are: % "Endpoint" - Endpoint to export to @@ -37,8 +37,11 @@ % "Timeout" - Maximum time above which exports % will abort % "HTTPHeaders" - Additional HTTP Headers + % "PreferredAggregationTemporality" + % - An aggregation temporality of + % - delta or cumulative % - % See also OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMetricEXPORTER + % See also OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMETRICEXPORTER arguments (Repeating) optionnames (1,:) {mustBeTextScalar} optionvalues diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m index cffe5e8..10e1f3b 100644 --- a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m @@ -1,5 +1,5 @@ classdef OtlpHttpMetricExporter < opentelemetry.sdk.metrics.MetricExporter -% OtlpHttpMetricExporter exports Metrics in OpenTelemetry Protocol format via +% OtlpHttpMetricExporter exports metrics in OpenTelemetry Protocol format via % HTTP. By default, it exports to the default address of the OpenTelemetry % Collector. @@ -17,7 +17,31 @@ methods function obj = OtlpHttpMetricExporter(optionnames, optionvalues) - + % OtlpHttpMetricExporter exports metrics in OpenTelemetry Protocol format via HTTP. + % EXP = OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMETRICEXPORTER + % creates an exporter that uses default configurations. + % + % EXP = + % OPENTELEMETRY.EXPORTERS.OTLP.OTLPHTTPMETRICEXPORTER(PARAM1, + % VALUE1, PARAM2, VALUE2, ...) specifies optional parameter + % name/value pairs. Parameters are: + % "Endpoint" - Endpoint to export to + % "Format" - Data format: "JSON" (default) or "binary" + % "JsonBytesMapping" - What to convert JSON bytes to. Supported + % values are "hex", "hexId" (default), and + % "base64". Default "hexId" + % converts to base 64 except for IDs + % which are converted to hexadecimals. + % "UseJsonName" - Whether to use JSON name of protobuf + % field to set the key of JSON + % "Timeout" - Maximum time above which exports + % will abort + % "HTTPHeaders" - Additional HTTP Headers + % "PreferredAggregationTemporality" + % - An aggregation temporality of + % - delta or cumulative + % + % See also OPENTELEMETRY.EXPORTERS.OTLP.OTLPGRPCMETRICEXPORTER arguments (Repeating) optionnames (1,:) {mustBeTextScalar} optionvalues diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m index a478fd2..6516c43 100644 --- a/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m @@ -1,6 +1,6 @@ function dexp = defaultMetricExporter % Get the default Metric exporter depending on installation -% EXP = OPENTELEMETRY.EXPORTERS.OTLP.DEFAULTMetricEXPORTER returns the +% EXP = OPENTELEMETRY.EXPORTERS.OTLP.DEFAULTMETRICEXPORTER returns the % default Metric exporter. OtlpHttpMetricExporter is the default if it is % installed. Otherwise, OtlpGrpcMetricExporter is the default. % diff --git a/myoutput.json b/myoutput.json deleted file mode 100644 index e69de29..0000000 diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 09b32f0..b5ed475 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -43,7 +43,8 @@ "ConstructorArguments", {reader.Proxy.ID}); obj.MetricReader = reader; end - + + function meter = getMeter(obj, mtname, mtversion, mtschema) arguments obj @@ -63,6 +64,7 @@ meter = opentelemetry.metrics.Meter(Meterproxy, mtname, mtversion, mtschema); end + function addMetricReader(obj, reader) arguments obj diff --git a/test/tmetrics.m b/test/tmetrics.m index 989fed3..7661d8b 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -58,7 +58,8 @@ function testExporterBasic(testCase) function testDefaultReader(testCase) reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(); - verifyEqual(testCase, string(class(reader.MetricExporter)), "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); + verifyEqual(testCase, string(class(reader.MetricExporter)), ... + "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); verifyEqual(testCase, reader.Interval, seconds(60)); verifyEqual(testCase, reader.Timeout, seconds(30)); end @@ -79,24 +80,24 @@ function testReaderBasic(testCase) function testAddMetricReader(testCase) metername = "foo"; countername = "bar"; - exporter1 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter("PreferredAggregationTemporality", "Delta"); - exporter2 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter("PreferredAggregationTemporality", "Delta"); + exporter1 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... + "PreferredAggregationTemporality", "Delta"); + exporter2 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... + "PreferredAggregationTemporality", "Delta"); reader1 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter1, ..., - "Interval", seconds(2), ... - "Timeout", seconds(1)); + "Interval", seconds(2), "Timeout", seconds(1)); reader2 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter2, ..., - "Interval", seconds(2), ... - "Timeout", seconds(1)); + "Interval", seconds(2), "Timeout", seconds(1)); p = opentelemetry.sdk.metrics.MeterProvider(reader1); - p.addMetricReader(reader2) + p.addMetricReader(reader2); mt = p.getMeter(metername); ct = mt.createCounter(countername); - % verify if the provider has two metric readers + % verify if the provider has two metric readers attached reader_size = size(p.MetricReader); verifyEqual(testCase,reader_size(2), 2); - % verify if the provider has two exported instances + % verify if the json results has two exported instances ct.add(1); pause(2.5); clear p; From 40ecc1228ffcc86fddca07fdcc763d8dfadb7b9c Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 5 Oct 2023 16:08:47 -0400 Subject: [PATCH 13/40] Creating MeterProvider API --- ...2d35e24d-9676-4df9-a3d0-369538f5d1c5.vsidx | Bin 0 -> 274174 bytes .../FileContentIndex/read.lock | 0 .vs/OpenTelemetry-Matlab/v16/.suo | Bin 0 -> 15360 bytes .vs/OpenTelemetry-Matlab/v16/Browse.VC.db | Bin 0 -> 438272 bytes .vs/OpenTelemetry-Matlab/v17/.wsuo | Bin 0 -> 13824 bytes .vs/OpenTelemetry-Matlab/v17/Browse.VC.db | Bin 0 -> 573440 bytes .vs/ProjectSettings.json | 3 + .vs/VSWorkspaceState.json | 6 ++ .vs/slnx.sqlite | Bin 0 -> 106496 bytes CMakeLists.txt | 1 + OtelMatlabProxyFactory.cpp | 1 + api/metrics/+opentelemetry/+metrics/Meter.m | 2 +- .../+opentelemetry/+metrics/MeterProvider.m | 69 ++++++++++++++++++ .../+opentelemetry/+metrics/Provider.m | 27 +++++++ .../+opentelemetry/+metrics/getMeter.m | 17 +++++ .../metrics/MeterProviderProxy.h | 53 ++++++++++++++ api/metrics/src/MeterProviderProxy.cpp | 39 ++++++++++ .../+sdk/+metrics/MeterProvider.m | 24 +----- .../sdk/metrics/MeterProviderProxy.h | 8 +- sdk/metrics/src/MeterProviderProxy.cpp | 25 ------- 20 files changed, 222 insertions(+), 53 deletions(-) create mode 100644 .vs/OpenTelemetry-Matlab/FileContentIndex/2d35e24d-9676-4df9-a3d0-369538f5d1c5.vsidx create mode 100644 .vs/OpenTelemetry-Matlab/FileContentIndex/read.lock create mode 100644 .vs/OpenTelemetry-Matlab/v16/.suo create mode 100644 .vs/OpenTelemetry-Matlab/v16/Browse.VC.db create mode 100644 .vs/OpenTelemetry-Matlab/v17/.wsuo create mode 100644 .vs/OpenTelemetry-Matlab/v17/Browse.VC.db create mode 100644 .vs/ProjectSettings.json create mode 100644 .vs/VSWorkspaceState.json create mode 100644 .vs/slnx.sqlite create mode 100644 api/metrics/+opentelemetry/+metrics/MeterProvider.m create mode 100644 api/metrics/+opentelemetry/+metrics/Provider.m create mode 100644 api/metrics/+opentelemetry/+metrics/getMeter.m create mode 100644 api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h create mode 100644 api/metrics/src/MeterProviderProxy.cpp diff --git a/.vs/OpenTelemetry-Matlab/FileContentIndex/2d35e24d-9676-4df9-a3d0-369538f5d1c5.vsidx b/.vs/OpenTelemetry-Matlab/FileContentIndex/2d35e24d-9676-4df9-a3d0-369538f5d1c5.vsidx new file mode 100644 index 0000000000000000000000000000000000000000..198c4feb332ba353f17b2e5565818b39adb19ee1 GIT binary patch literal 274174 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 literal 0 HcmV?d00001 diff --git a/.vs/OpenTelemetry-Matlab/v16/Browse.VC.db b/.vs/OpenTelemetry-Matlab/v16/Browse.VC.db new file mode 100644 index 0000000000000000000000000000000000000000..ff54ab38f95093c74620cbe68b1b9d49fd3d1895 GIT binary patch literal 438272 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 X?yOLf_b9dpdf~d>vP}Zp8M2b?= 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 yX|S}gFkdJR6-$Mo;=)kjP literal 0 HcmV?d00001 diff --git a/.vs/OpenTelemetry-Matlab/v17/Browse.VC.db b/.vs/OpenTelemetry-Matlab/v17/Browse.VC.db new file mode 100644 index 0000000000000000000000000000000000000000..948009cd4c9cb3eec76700346163db4a7fd408f4 GIT binary patch literal 573440 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 CFJD#w literal 0 HcmV?d00001 diff --git a/CMakeLists.txt b/CMakeLists.txt index cadc935..68a3d81 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -215,6 +215,7 @@ set(OPENTELEMETRY_PROXY_SOURCES ${TRACE_API_SOURCE_DIR}/SpanProxy.cpp ${TRACE_API_SOURCE_DIR}/SpanContextProxy.cpp ${COMMON_API_SOURCE_DIR}/attribute.cpp + ${METRICS_API_SOURCE_DIR}/MeterProviderProxy.cpp ${METRICS_API_SOURCE_DIR}/MeterProxy.cpp ${METRICS_API_SOURCE_DIR}/CounterProxy.cpp ${METRICS_API_SOURCE_DIR}/UpDownCounterProxy.cpp diff --git a/OtelMatlabProxyFactory.cpp b/OtelMatlabProxyFactory.cpp index 925094d..1677dd6 100644 --- a/OtelMatlabProxyFactory.cpp +++ b/OtelMatlabProxyFactory.cpp @@ -34,6 +34,7 @@ libmexclass::proxy::MakeResult OtelMatlabProxyFactory::make_proxy(const libmexclass::proxy::ClassName& class_name, const libmexclass::proxy::FunctionArguments& constructor_arguments) { + REGISTER_PROXY(libmexclass.opentelemetry.MeterProviderProxy, libmexclass::opentelemetry::MeterProviderProxy); REGISTER_PROXY(libmexclass.opentelemetry.TracerProviderProxy, libmexclass::opentelemetry::TracerProviderProxy); //REGISTER_PROXY(libmexclass.opentelemetry.TracerProxy, libmexclass::opentelemetry::TracerProxy); REGISTER_PROXY(libmexclass.opentelemetry.SpanProxy, libmexclass::opentelemetry::SpanProxy); diff --git a/api/metrics/+opentelemetry/+metrics/Meter.m b/api/metrics/+opentelemetry/+metrics/Meter.m index 250a5b9..be726f0 100644 --- a/api/metrics/+opentelemetry/+metrics/Meter.m +++ b/api/metrics/+opentelemetry/+metrics/Meter.m @@ -14,7 +14,7 @@ Proxy % Proxy object to interface C++ code end - methods (Access={?opentelemetry.sdk.metrics.MeterProvider}) + methods (Access={?opentelemetry.sdk.metrics.MeterProvider, ?opentelemetry.metrics.MeterProvider}) function obj = Meter(proxy, mtname, mtversion, mtschema) % Private constructor. Use getMeter method of MeterProvider diff --git a/api/metrics/+opentelemetry/+metrics/MeterProvider.m b/api/metrics/+opentelemetry/+metrics/MeterProvider.m new file mode 100644 index 0000000..c55e398 --- /dev/null +++ b/api/metrics/+opentelemetry/+metrics/MeterProvider.m @@ -0,0 +1,69 @@ +classdef MeterProvider < handle + % A meter provider stores a set of configurations used in a distributed + % metrics system. + + % Copyright 2023 The MathWorks, Inc. + + properties (Access={?opentelemetry.sdk.metrics.MeterProvider}) + Proxy % Proxy object to interface C++ code + end + + methods (Access={?opentelemetry.metrics.Provider, ?opentelemetry.sdk.metrics.MeterProvider}) + function obj = MeterProvider(skip) + % constructor + % "skip" input signals skipping construction + if nargin < 1 || skip ~= "skip" + obj.Proxy = libmexclass.proxy.Proxy("Name", ... + "libmexclass.opentelemetry.MeterProviderProxy", ... + "ConstructorArguments", {}); + end + end + end + + methods + function meter = getMeter(obj, mname, mversion, mschema) + % GETMETER Create a meter object used to generate metrics. + % M = GETMETER(MP, NAME) returns a meter with the name + % NAME that uses all the configurations specified in meter + % provider MP. + % + % M = GETMETER(MP, NAME, VERSION, SCHEMA) also specifies + % the meter version and the URL that documents the schema + % of the generated meters. + % + % See also OPENTELEMETRY.METRICS.METER + arguments + obj + mname + mversion = "" + mschema = "" + end + % name, version, schema accepts any types that can convert to a + % string + import opentelemetry.common.mustBeScalarString + mname = mustBeScalarString(mname); + mversion = mustBeScalarString(mversion); + mschema = mustBeScalarString(mschema); + id = obj.Proxy.getMeter(mname, mversion, mschema); + meterproxy = libmexclass.proxy.Proxy("Name", ... + "libmexclass.opentelemetry.MeterProxy", "ID", id); + meter = opentelemetry.metrics.Meter(meterproxy, mname, mversion, mschema); + end + + function setMeterProvider(obj) + % SETMETERPROVIDER Set global instance of meter provider + % SETMETERPROVIDER(MP) sets the meter provider MP as + % the global instance. + % + % See also OPENTELEMETRY.METRICS.PROVIDER.GETMETERPROVIDER + obj.Proxy.setMeterProvider(); + end + end + + % methods(Access=?opentelemetry.sdk.metrics.Cleanup) + % function postShutdown(obj) + % % POSTSHUTDOWN Handle post-shutdown tasks + % obj.Proxy.postShutdown(); + % end + % end +end diff --git a/api/metrics/+opentelemetry/+metrics/Provider.m b/api/metrics/+opentelemetry/+metrics/Provider.m new file mode 100644 index 0000000..beca183 --- /dev/null +++ b/api/metrics/+opentelemetry/+metrics/Provider.m @@ -0,0 +1,27 @@ +classdef Provider +% Get and set the global instance of meter provider + +% Copyright 2023 The MathWorks, Inc. + + methods (Static) + function p = getMeterProvider() + % Get the global instance of meter provider + % MP = OPENTELEMETRY.METRICS.PROVIDER.GETMETERPROVIDER gets + % the global instance of meter provider. + % + % See also OPENTELEMETRY.METRICS.PROVIDER.SETMETERPROVIDER + + p = opentelemetry.metrics.MeterProvider(); + end + + function setMeterProvider(p) + % Set the global instance of meter provider + % OPENTELEMETRY.METRICS.PROVIDER.GETMETERPROVIDER(MP) sets + % MP as the global instance of meter provider. + % + % See also OPENTELEMETRY.METRICS.PROVIDER.GETMETERPROVIDER + p.setMeterProvider(); + end + end + +end diff --git a/api/metrics/+opentelemetry/+metrics/getMeter.m b/api/metrics/+opentelemetry/+metrics/getMeter.m new file mode 100644 index 0000000..a741cca --- /dev/null +++ b/api/metrics/+opentelemetry/+metrics/getMeter.m @@ -0,0 +1,17 @@ +function meter = getMeter(mname, varargin) +% Create a meter from the global meter provider instance +% M = OPENTELEMETRY.TRACE.GETMETER(NAME) returns a meter with the +% specified name created from the global meter provider instance. +% +% M = OPENTELEMETRY.METRICS.GETMETER(NAME, VERSION, SCHEMA) also +% specifies the meter version and the URL that documents the schema +% of the generated metrics. +% +% See also OPENTELEMETRY.SDK.METRICS.METERPROVIDER, +% OPENTELEMETRY.METRICS.METER, +% OPENTELEMETRY.METRICS.PROVIDER.SETMETERPROVIDER + +% Copyright 2023 The MathWorks, Inc. + +provider = opentelemetry.metrics.Provider.getMeterProvider(); +meter = getMeter(provider, mname, varargin{:}); diff --git a/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h b/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h new file mode 100644 index 0000000..1d01acc --- /dev/null +++ b/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h @@ -0,0 +1,53 @@ +// Copyright 2023 The MathWorks, Inc. + +#pragma once + +#include "libmexclass/proxy/Proxy.h" +#include "libmexclass/proxy/method/Context.h" + +#include "opentelemetry/sdk/metrics/meter_provider_factory.h" +#include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/exporters/otlp/otlp_http_exporter_factory.h" +#include "opentelemetry/metrics/meter_provider.h" +#include "opentelemetry/metrics/provider.h" +#include "opentelemetry/metrics/noop.h" + +namespace metrics_api = opentelemetry::metrics; +namespace metrics_sdk = opentelemetry::sdk::metrics; +namespace metrics_exporter = opentelemetry::exporter::otlp; +namespace nostd = opentelemetry::nostd; +namespace resource = opentelemetry::sdk::resource; + +namespace libmexclass::opentelemetry { +class MeterProviderProxy : public libmexclass::proxy::Proxy { + public: + MeterProviderProxy(nostd::shared_ptr mp) : CppMeterProvider(mp) { + REGISTER_METHOD(MeterProviderProxy, getMeter); + REGISTER_METHOD(MeterProviderProxy, setMeterProvider); + REGISTER_METHOD(MeterProviderProxy, postShutdown); + } + + // Static make method should only be used by getMeterProvider. It gets the global instance + // instead of creating a new instance + static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { + return std::make_shared(metrics_api::Provider::GetMeterProvider()); + } + + void getMeter(libmexclass::proxy::method::Context& context); + + void setMeterProvider(libmexclass::proxy::method::Context& context); + + nostd::shared_ptr getInstance() { + return CppMeterProvider; + } + + void postShutdown(libmexclass::proxy::method::Context& context) { + // Replace meter provider with a no-op instance. Subsequent metrics won't be recorded + nostd::shared_ptr noop(new metrics_api::NoopMeterProvider); + CppMeterProvider.swap(noop); + } + + protected: + nostd::shared_ptr CppMeterProvider; +}; +} // namespace libmexclass::opentelemetry diff --git a/api/metrics/src/MeterProviderProxy.cpp b/api/metrics/src/MeterProviderProxy.cpp new file mode 100644 index 0000000..4263170 --- /dev/null +++ b/api/metrics/src/MeterProviderProxy.cpp @@ -0,0 +1,39 @@ +// Copyright 2023 The MathWorks, Inc. + +#include "opentelemetry-matlab/metrics/MeterProviderProxy.h" +#include "opentelemetry-matlab/metrics/MeterProxy.h" +#include "libmexclass/proxy/ProxyManager.h" + +#include "opentelemetry/metrics/provider.h" + +#include "MatlabDataArray.hpp" +namespace libmexclass::opentelemetry { +void MeterProviderProxy::getMeter(libmexclass::proxy::method::Context& context) { + // Always assumes 3 inputs + matlab::data::StringArray name_mda = context.inputs[0]; + std::string name = static_cast(name_mda[0]); + matlab::data::StringArray version_mda = context.inputs[1]; + std::string version = static_cast(version_mda[0]); + matlab::data::StringArray schema_mda = context.inputs[2]; + std::string schema = static_cast(schema_mda[0]); + + auto mt = CppMeterProvider->GetMeter(name, version, schema); + + // instantiate a MeterProxy instance + MeterProxy* newproxy = new MeterProxy(mt); + auto mtproxy = std::shared_ptr(newproxy); + + // obtain a proxy ID + libmexclass::proxy::ID proxyid = libmexclass::proxy::ProxyManager::manageProxy(mtproxy); + + // return the ID + matlab::data::ArrayFactory factory; + auto proxyid_mda = factory.createScalar(proxyid); + context.outputs[0] = proxyid_mda; +} + +void MeterProviderProxy::setMeterProvider(libmexclass::proxy::method::Context& context) { + metrics_api::Provider::SetMeterProvider(CppMeterProvider); +} + +} // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index ec019eb..876d79a 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -1,11 +1,11 @@ -classdef MeterProvider < handle +classdef MeterProvider < opentelemetry.metrics.MeterProvider & handle % An SDK implementation of meter provider, which stores a set of configurations used % in a metrics system. % Copyright 2023 The MathWorks, Inc. properties (Access=private) - Proxy + isShutdown (1,1) logical = false end methods @@ -27,30 +27,10 @@ % % See also OPENTELEMETRY.SDK.METRICS.PERIODICEXPORTINGMETRICREADER % OPENTELEMETRY.SDK.METRICS.VIEW - obj.Proxy = libmexclass.proxy.Proxy("Name", ... "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... "ConstructorArguments", {}); end - - function meter = getMeter(obj, mtname, mtversion, mtschema) - arguments - obj - mtname - mtversion = "" - mtschema = "" - end - % name, version, schema accepts any types that can convert to a - % string - import opentelemetry.common.mustBeScalarString - mtname = mustBeScalarString(mtname); - mtversion = mustBeScalarString(mtversion); - mtschema = mustBeScalarString(mtschema); - id = obj.Proxy.getMeter(mtname, mtversion, mtschema); - Meterproxy = libmexclass.proxy.Proxy("Name", ... - "libmexclass.opentelemetry.MeterProxy", "ID", id); - meter = opentelemetry.metrics.Meter(Meterproxy, mtname, mtversion, mtschema); - end end end diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h index 3526822..d7b71ae 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h @@ -23,6 +23,7 @@ #include "opentelemetry/sdk/metrics/push_metric_exporter.h" #include "opentelemetry-matlab/metrics/MeterProxy.h" +#include "opentelemetry-matlab/metrics/MeterProviderProxy.h" namespace metrics_api = opentelemetry::metrics; namespace nostd = opentelemetry::nostd; @@ -32,16 +33,13 @@ namespace otlpexporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::sdk { -class MeterProviderProxy : public libmexclass::proxy::Proxy { +class MeterProviderProxy : public libmexclass::opentelemetry::MeterProviderProxy { public: - MeterProviderProxy(nostd::shared_ptr mp) : CppMeterProvider(mp) { - REGISTER_METHOD(MeterProviderProxy, getMeter); + MeterProviderProxy(nostd::shared_ptr mp) : libmexclass::opentelemetry::MeterProviderProxy(mp) { } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); - void getMeter(libmexclass::proxy::method::Context& context); - protected: nostd::shared_ptr CppMeterProvider; }; diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index e0eb3c3..e0d8910 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -26,29 +26,4 @@ libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy return out; } -void MeterProviderProxy::getMeter(libmexclass::proxy::method::Context& context) { - // Always assumes 3 inputs - matlab::data::StringArray name_mda = context.inputs[0]; - std::string name = static_cast(name_mda[0]); - matlab::data::StringArray version_mda = context.inputs[1]; - std::string version = static_cast(version_mda[0]); - matlab::data::StringArray schema_mda = context.inputs[2]; - std::string schema = static_cast(schema_mda[0]); - - auto mt = CppMeterProvider->GetMeter(name, version, schema); - - // instantiate a MeterProxy instance - MeterProxy* newproxy = new MeterProxy(mt); - auto mtproxy = std::shared_ptr(newproxy); - - // obtain a proxy ID - libmexclass::proxy::ID proxyid = libmexclass::proxy::ProxyManager::manageProxy(mtproxy); - - // return the ID - matlab::data::ArrayFactory factory; - auto proxyid_mda = factory.createScalar(proxyid); - context.outputs[0] = proxyid_mda; -} - - } // namespace libmexclass::opentelemetry From 68a098513d194ca46f284ae0011f2e820a15ccd0 Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Fri, 6 Oct 2023 10:10:08 -0400 Subject: [PATCH 14/40] fix: invalid instrument names with spaces temporary fix for issue #28; change size to numel in tmetrics --- api/metrics/+opentelemetry/+metrics/Meter.m | 9 ++++++--- test/tmetrics.m | 12 +++++++----- 2 files changed, 13 insertions(+), 8 deletions(-) diff --git a/api/metrics/+opentelemetry/+metrics/Meter.m b/api/metrics/+opentelemetry/+metrics/Meter.m index 250a5b9..8ed1295 100644 --- a/api/metrics/+opentelemetry/+metrics/Meter.m +++ b/api/metrics/+opentelemetry/+metrics/Meter.m @@ -37,7 +37,8 @@ ctunit = "" end import opentelemetry.common.mustBeScalarString - ctname = mustBeScalarString(ctname); + ctname = mustBeScalarString(ctname); + ctname = strrep(ctname, ' ', '_'); ctdescription = mustBeScalarString(ctdescription); ctunit = mustBeScalarString(ctunit); id = obj.Proxy.createCounter(ctname, ctdescription, ctunit); @@ -56,7 +57,8 @@ end import opentelemetry.common.mustBeScalarString - ctname = mustBeScalarString(ctname); + ctname = mustBeScalarString(ctname); + ctname = strrep(ctname, ' ', '_'); ctdescription = mustBeScalarString(ctdescription); ctunit = mustBeScalarString(ctunit); id = obj.Proxy.createUpDownCounter(ctname, ctdescription, ctunit); @@ -75,7 +77,8 @@ end import opentelemetry.common.mustBeScalarString - hiname = mustBeScalarString(hiname); + hiname = mustBeScalarString(hiname); + hiname = strrep(hiname, ' ', '_'); hidescription = mustBeScalarString(hidescription); hiunit = mustBeScalarString(hiunit); id = obj.Proxy.createHistogram(hiname, hidescription, hiunit); diff --git a/test/tmetrics.m b/test/tmetrics.m index 7661d8b..212f1f0 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -94,16 +94,17 @@ function testAddMetricReader(testCase) ct = mt.createCounter(countername); % verify if the provider has two metric readers attached - reader_size = size(p.MetricReader); - verifyEqual(testCase,reader_size(2), 2); + reader_count = numel(p.MetricReader); + verifyEqual(testCase,reader_count, 2); - % verify if the json results has two exported instances + % verify if the json results has two exported instances after + % adding a single value ct.add(1); pause(2.5); clear p; results = readJsonResults(testCase); - result_size = size(results); - verifyEqual(testCase,result_size(2), 2); + result_count = numel(results); + verifyEqual(testCase,result_count, 2); end @@ -189,6 +190,7 @@ function testCounterDelta(testCase) verifyEqual(testCase, dp2.asDouble, vals(2)); end + function testCounterAddAttributes(testCase) % test names, added value and attributes in Counter From 1773af82c0657d61a0d1ca70ebfe450f4308e4f9 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Fri, 6 Oct 2023 10:46:53 -0400 Subject: [PATCH 15/40] Finishing and cleaning up MeterProvider api --- .../+opentelemetry/+metrics/MeterProvider.m | 7 ------- api/metrics/+opentelemetry/+metrics/getMeter.m | 17 ----------------- .../metrics/MeterProviderProxy.h | 7 ------- .../+sdk/+metrics/MeterProvider.m | 2 +- 4 files changed, 1 insertion(+), 32 deletions(-) delete mode 100644 api/metrics/+opentelemetry/+metrics/getMeter.m diff --git a/api/metrics/+opentelemetry/+metrics/MeterProvider.m b/api/metrics/+opentelemetry/+metrics/MeterProvider.m index c55e398..ec3b615 100644 --- a/api/metrics/+opentelemetry/+metrics/MeterProvider.m +++ b/api/metrics/+opentelemetry/+metrics/MeterProvider.m @@ -59,11 +59,4 @@ function setMeterProvider(obj) obj.Proxy.setMeterProvider(); end end - - % methods(Access=?opentelemetry.sdk.metrics.Cleanup) - % function postShutdown(obj) - % % POSTSHUTDOWN Handle post-shutdown tasks - % obj.Proxy.postShutdown(); - % end - % end end diff --git a/api/metrics/+opentelemetry/+metrics/getMeter.m b/api/metrics/+opentelemetry/+metrics/getMeter.m deleted file mode 100644 index a741cca..0000000 --- a/api/metrics/+opentelemetry/+metrics/getMeter.m +++ /dev/null @@ -1,17 +0,0 @@ -function meter = getMeter(mname, varargin) -% Create a meter from the global meter provider instance -% M = OPENTELEMETRY.TRACE.GETMETER(NAME) returns a meter with the -% specified name created from the global meter provider instance. -% -% M = OPENTELEMETRY.METRICS.GETMETER(NAME, VERSION, SCHEMA) also -% specifies the meter version and the URL that documents the schema -% of the generated metrics. -% -% See also OPENTELEMETRY.SDK.METRICS.METERPROVIDER, -% OPENTELEMETRY.METRICS.METER, -% OPENTELEMETRY.METRICS.PROVIDER.SETMETERPROVIDER - -% Copyright 2023 The MathWorks, Inc. - -provider = opentelemetry.metrics.Provider.getMeterProvider(); -meter = getMeter(provider, mname, varargin{:}); diff --git a/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h b/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h index 1d01acc..947b0c9 100644 --- a/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h +++ b/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h @@ -24,7 +24,6 @@ class MeterProviderProxy : public libmexclass::proxy::Proxy { MeterProviderProxy(nostd::shared_ptr mp) : CppMeterProvider(mp) { REGISTER_METHOD(MeterProviderProxy, getMeter); REGISTER_METHOD(MeterProviderProxy, setMeterProvider); - REGISTER_METHOD(MeterProviderProxy, postShutdown); } // Static make method should only be used by getMeterProvider. It gets the global instance @@ -41,12 +40,6 @@ class MeterProviderProxy : public libmexclass::proxy::Proxy { return CppMeterProvider; } - void postShutdown(libmexclass::proxy::method::Context& context) { - // Replace meter provider with a no-op instance. Subsequent metrics won't be recorded - nostd::shared_ptr noop(new metrics_api::NoopMeterProvider); - CppMeterProvider.swap(noop); - } - protected: nostd::shared_ptr CppMeterProvider; }; diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 876d79a..88e6df3 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -10,7 +10,7 @@ methods function obj = MeterProvider() - % SDK implementation of tracer provider + % SDK implementation of meter provider % MP = OPENTELEMETRY.SDK.METRICS.METERPROVIDER creates a meter % provider that uses a periodic exporting metric reader and default configurations. % From e995d790549d47703b33720bc340fb9b5d5757e8 Mon Sep 17 00:00:00 2001 From: Rick Tu Date: Fri, 6 Oct 2023 11:09:30 -0400 Subject: [PATCH 16/40] fix: comments add comments on using strrep for name input of synchronous instruments --- api/metrics/+opentelemetry/+metrics/Meter.m | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/api/metrics/+opentelemetry/+metrics/Meter.m b/api/metrics/+opentelemetry/+metrics/Meter.m index 8ed1295..4e49684 100644 --- a/api/metrics/+opentelemetry/+metrics/Meter.m +++ b/api/metrics/+opentelemetry/+metrics/Meter.m @@ -38,6 +38,8 @@ end import opentelemetry.common.mustBeScalarString ctname = mustBeScalarString(ctname); + % cpp-opentelemetry end does not allow string input with spaces, + % replace any spaces with underscores as a temporary fix ctname = strrep(ctname, ' ', '_'); ctdescription = mustBeScalarString(ctdescription); ctunit = mustBeScalarString(ctunit); @@ -58,6 +60,8 @@ import opentelemetry.common.mustBeScalarString ctname = mustBeScalarString(ctname); + % cpp-opentelemetry end does not allow string input with spaces, + % replace any spaces with underscores as a temporary fix ctname = strrep(ctname, ' ', '_'); ctdescription = mustBeScalarString(ctdescription); ctunit = mustBeScalarString(ctunit); @@ -78,6 +82,8 @@ import opentelemetry.common.mustBeScalarString hiname = mustBeScalarString(hiname); + % cpp-opentelemetry end does not allow string input with spaces, + % replace any spaces with underscores as a temporary fix hiname = strrep(hiname, ' ', '_'); hidescription = mustBeScalarString(hidescription); hiunit = mustBeScalarString(hiunit); From ac793c5f7ebc5a04b0fde6edcd4c46b6207240e6 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Wed, 11 Oct 2023 09:12:26 -0400 Subject: [PATCH 17/40] Adding test for get and set meter --- test/tmetrics.m | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/test/tmetrics.m b/test/tmetrics.m index c452504..280af87 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -358,6 +358,35 @@ function testHistogramRecordAttributes(testCase) verifyEqual(testCase, str2double(counts{len}), sum(vals>bounds(len-1))); end + + function testGetSetMeterProvider(testCase) + % testGetSetMeterProvider: setting and getting global instance of MeterProvider + mp = opentelemetry.sdk.metrics.MeterProvider(); + setMeterProvider(mp); + + metername = "foo"; + countername = "bar"; + m = getMeter(mp, metername); + c = createCounter(m, countername); + + % create testing value + val = 10; + + % add value and attributes + c.add(val); + + pause(75); + + % perform test comparisons + results = readJsonResults(testCase); + results = results{1}; + % check a counter has been created, and check its resource to identify the + % correct MeterProvider has been used + verifyNotEmpty(testCase, results); + + verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.metrics.name), countername); + verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.scope.name), metername); + end end From ec003105da40b139579b0d2fb081bf5fb00498a9 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Wed, 11 Oct 2023 13:00:27 -0400 Subject: [PATCH 18/40] Fixing error from merge --- .../opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h | 2 +- test/myoutput.json | 0 2 files changed, 1 insertion(+), 1 deletion(-) delete mode 100644 test/myoutput.json diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h index f9058b6..37a8d57 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h @@ -35,7 +35,7 @@ namespace otlpexporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::sdk { class MeterProviderProxy : public libmexclass::opentelemetry::MeterProviderProxy { public: - MeterProviderProxy(nostd::shared_ptr mp) : libmexclass::opentelemetry::MeterProviderProxy(mp) { + MeterProviderProxy(nostd::shared_ptr mp) : libmexclass::opentelemetry::MeterProviderProxy(mp), CppMeterProvider(mp) { REGISTER_METHOD(MeterProviderProxy, addMetricReader); } diff --git a/test/myoutput.json b/test/myoutput.json deleted file mode 100644 index e69de29..0000000 From 3af790a438cfe2ee488d9e8967de503da0a81521 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Wed, 11 Oct 2023 13:02:10 -0400 Subject: [PATCH 19/40] Removing .vs folder --- .../2d35e24d-9676-4df9-a3d0-369538f5d1c5.vsidx | Bin 274174 -> 0 bytes .../FileContentIndex/read.lock | 0 .vs/OpenTelemetry-Matlab/v16/.suo | Bin 22528 -> 0 bytes .vs/OpenTelemetry-Matlab/v16/Browse.VC.db | Bin 528384 -> 0 bytes .vs/OpenTelemetry-Matlab/v17/.wsuo | Bin 13824 -> 0 bytes .vs/OpenTelemetry-Matlab/v17/Browse.VC.db | Bin 573440 -> 0 bytes .vs/ProjectSettings.json | 3 --- .vs/VSWorkspaceState.json | 6 ------ .vs/slnx.sqlite | Bin 118784 -> 0 bytes 9 files changed, 9 deletions(-) delete mode 100644 .vs/OpenTelemetry-Matlab/FileContentIndex/2d35e24d-9676-4df9-a3d0-369538f5d1c5.vsidx delete mode 100644 .vs/OpenTelemetry-Matlab/FileContentIndex/read.lock delete mode 100644 .vs/OpenTelemetry-Matlab/v16/.suo delete mode 100644 .vs/OpenTelemetry-Matlab/v16/Browse.VC.db delete mode 100644 .vs/OpenTelemetry-Matlab/v17/.wsuo delete mode 100644 .vs/OpenTelemetry-Matlab/v17/Browse.VC.db delete mode 100644 .vs/ProjectSettings.json delete mode 100644 .vs/VSWorkspaceState.json delete mode 100644 .vs/slnx.sqlite diff --git a/.vs/OpenTelemetry-Matlab/FileContentIndex/2d35e24d-9676-4df9-a3d0-369538f5d1c5.vsidx b/.vs/OpenTelemetry-Matlab/FileContentIndex/2d35e24d-9676-4df9-a3d0-369538f5d1c5.vsidx deleted file mode 100644 index 198c4feb332ba353f17b2e5565818b39adb19ee1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 274174 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 DV~jKu diff --git a/.vs/OpenTelemetry-Matlab/v17/.wsuo b/.vs/OpenTelemetry-Matlab/v17/.wsuo deleted file mode 100644 index 58370ba32629487ae690796b855a058f856f3728..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13824 zcmeI3U2{`K7{@mvD&iZWhzJ@T#$iU&DNt&KkpWv!XRNJld6^N1Nt?D5+N6`DV84SO zz+1iW-Vfjm-vDnM$2-0Cf;%sz{C|7SCY#gb^qi9*6tbO@v)Qw||9yF$XaCQ0(%9pBl?rrQc&v@lIFK=Ek_8DdOHa0eRL|)l`+D0odWh(lso4h$^%DPw0 zI$N1I?K3+Yd+y6hyACFQ`g!W~zklZ5(8Jr$1~n#ySTWbl7eZf9?wt9qUDJ+b`^-~0 zf4MtW^d7veyu{ZghY#+mS=I=uW?t8{)}p9uKCIX2b~pn**f+usC(N2qmd%pp&$Z|w zkEx{E2{uF9_Y<~&df=k}FX?jnPq|A@|DA1e<^B7kvjXf_yNi8|mSe}+bHAK@ z_rIsfKRT=M(s=Arp-0W!RlttGNW32S4R9tf9d!Sb_w1?x@bntr0^HbRdZIDb&cbuSRZ__ZpM^b z)wr&jqh`Pi22EN%2Q`0q5}Y>a{LvBDiH{ElW(|tEGY9%fzmvZ9^`F&z{L{4LYuRdAAZepk-WDWxiz=;pGUz0>_5Pu>&tIk1r|rM( zRk72h2{SA2Z(L|qX(F=4#GIRM;){97i$z)ZJqKN@L4Z78L0>M-^P6&w*6;M zlkR`t{x|Law9dRaoq$APZb}16Rtg7n4!7Ec0iDq3NnH|yRVb^~HLdxX4DxqS?Vi>} z8aGqsf}&4Ryu3ND(JXJN1@C9TKO|hZY_C#U{qGg7>!%z1sQqEp%aQ{21N%Rx9f(U> z{~W%f^Z(-Nx@T|?XMZ~5uZxq;S}Anx+TFot{%QQ*IQu)U`K}0+IOwHtEh;({I@w~K ze-_`xxY~^|T1M<`CM=B3KfpxKf=J|9@y}Ih2`A%HSnBsTEcr*D;A^ad|EyD<{c`#j z#Yem6rQbJ%TCwx5o6l5+G{A(T=~xE+%LD{()q*Jf6zsW z;=}uq`BklTz=-0|jdAh^HYw;e{*$>o{@o5gU_d2}qGbJ$xbd+60dnvej~qNDUhD8L z-*G#Uq~+#1hc_{ZnymRn@w>s$XF9sMkynE6*o$=P_Ws?M2Y$bswy%}qQu&_`)_%>} z9=#9ZWX5E{|Krfz-QD1)oo}>$RQ|Hqf4CPqm{k6IZ2wcsf3NL7XWw?U|BnIxv-~5C z{qOU?rWJ_l|8_k8)1H4lKL1nOpGWEZPZNKf79$}pbJZMcL?KUy{1;A<)c&KZj(_<0 z^iR~cYMJi3eiJ}kW=*AM#eR$O2G{kSIB_!`i~or}zm)=?v&zMPf;cacmjI#Zb-G^$ zFs6FPsL;u9{_mu~Z#{o1cFrrBB~dTm=a>}hX1;Mul=w4To|s0`^~d)*p^N0>ja$FI z7)GK7^o%G}*-VHHbBB*cllXs*_l0|PCBhAR@wE_QOUfR{E3FftFf0Pe-_tHKH>a*`A6q@^F%ZWFPHtEvf~K! z;cKh^SOj+5y(MZ6fcGD~&(4Y;xBrtuEr)V{USss-&W#|8|AoG~{g1=Hs5w`)9=s!) zZOok(C6!*Y8X)_Z`u9)7YF+#V``h3Dk|ghzUR8zfnq8;U(~PCO_|@%gU;u?mCu6Z-a}<+OB?q6 zdtIaEq`9Iu$u-NFYs!}_m#fNu;1?cOwI_I!b(O3(yjo*E(eD#EB~NV{2XPQ=$l>B# yX|S}gFkdJR6-$Mo;=)kjP diff --git a/.vs/OpenTelemetry-Matlab/v17/Browse.VC.db b/.vs/OpenTelemetry-Matlab/v17/Browse.VC.db deleted file mode 100644 index 948009cd4c9cb3eec76700346163db4a7fd408f4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 573440 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 From 8c3a10cc61e11119ebc3bc0136e4eb698e8593b9 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 12 Oct 2023 08:47:39 -0400 Subject: [PATCH 20/40] Add resource property --- .../+sdk/+metrics/MeterProvider.m | 37 ++++++++++++++++++- .../sdk/metrics/MeterProviderProxy.h | 4 ++ sdk/metrics/src/MeterProviderProxy.cpp | 13 +++++-- test/myoutput.json | 0 4 files changed, 49 insertions(+), 5 deletions(-) create mode 100644 test/myoutput.json diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 58a5c72..70612af 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -13,8 +13,12 @@ MetricReader end + properties (Access=public) + Resource + end + methods - function obj = MeterProvider(reader) + function obj = MeterProvider(reader, optionnames, optionvalues) % SDK implementation of tracer provider % MP = OPENTELEMETRY.SDK.METRICS.METERPROVIDER creates a meter % provider that uses a periodic exporting metric reader and default configurations. @@ -38,11 +42,40 @@ "libmexclass.proxy.Proxy"])} = ... opentelemetry.sdk.metrics.PeriodicExportingMetricReader() end + + arguments (Repeating) + optionnames (1,:) {mustBeTextScalar} + optionvalues + end + + validnames = ["Resource"]; + resourcekeys = string.empty(); + resourcevalues = {}; + resource = dictionary(resourcekeys, resourcevalues); + for i = 1:length(optionnames) + namei = validatestring(optionnames{i}, validnames); + valuei = optionvalues{i}; + if strcmp(namei, "Resource") + if ~isa(valuei, "dictionary") + error("opentelemetry:sdk:metrics:MeterProvider:InvalidResourceType", ... + "Attibutes input must be a dictionary."); + end + resource = valuei; + resourcekeys = keys(valuei); + resourcevalues = values(valuei,"cell"); + % collapse one level of cells, as this may be due to + % a behavior of dictionary.values + if all(cellfun(@iscell, resourcevalues)) + resourcevalues = [resourcevalues{:}]; + end + end + end obj.Proxy = libmexclass.proxy.Proxy("Name", ... "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... - "ConstructorArguments", {reader.Proxy.ID}); + "ConstructorArguments", {reader.Proxy.ID, resourcekeys, resourcevalues}); obj.MetricReader = reader; + obj.Resource = resource; end function addMetricReader(obj, reader) diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h index 37a8d57..d4882b6 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h @@ -21,15 +21,19 @@ #include "opentelemetry/sdk/metrics/meter_provider.h" #include "opentelemetry/sdk/metrics/meter_provider_factory.h" #include "opentelemetry/sdk/metrics/push_metric_exporter.h" +#include "opentelemetry/sdk/resource/resource.h" + #include "opentelemetry-matlab/metrics/MeterProxy.h" #include "opentelemetry-matlab/metrics/MeterProviderProxy.h" +#include "opentelemetry-matlab/sdk/common/resource.h" namespace metrics_api = opentelemetry::metrics; namespace nostd = opentelemetry::nostd; namespace metrics_sdk = opentelemetry::sdk::metrics; namespace common = opentelemetry::common; namespace otlpexporter = opentelemetry::exporter::otlp; +namespace resource = opentelemetry::sdk::resource; namespace libmexclass::opentelemetry::sdk { diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index 7b57f09..f73778f 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -15,15 +15,22 @@ libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy matlab::data::TypedArray readerid_mda = constructor_arguments[0]; libmexclass::proxy::ID readerid = readerid_mda[0]; + matlab::data::StringArray resourcenames_mda = constructor_arguments[1]; + size_t nresourceattrs = resourcenames_mda.getNumberOfElements(); + matlab::data::CellArray resourcevalues_mda = constructor_arguments[2]; + + auto resource_custom = createResource(resourcenames_mda, resourcevalues_mda); + auto reader = std::static_pointer_cast( libmexclass::proxy::ProxyManager::getProxy(readerid))->getInstance(); - auto p = metrics_sdk::MeterProviderFactory::Create(); + auto p = metrics_sdk::MeterProviderFactory::Create(NULL, std::move(resource_custom)); auto *p_sdk = static_cast(p.get()); p_sdk->AddMetricReader(std::move(reader)); - + auto p_out = nostd::shared_ptr(std::move(p)); + out = std::make_shared(p_out); - + return out; } diff --git a/test/myoutput.json b/test/myoutput.json new file mode 100644 index 0000000..e69de29 From 8268a153d405139746d40c316fea0b2012e99c81 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 12 Oct 2023 10:45:34 -0400 Subject: [PATCH 21/40] Lowering reader interval for test --- test/tmetrics.m | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/test/tmetrics.m b/test/tmetrics.m index 1a52b61..7284858 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -540,7 +540,11 @@ function testHistogramDelta(testCase) function testGetSetMeterProvider(testCase) % testGetSetMeterProvider: setting and getting global instance of MeterProvider - mp = opentelemetry.sdk.metrics.MeterProvider(); + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... + "PreferredAggregationTemporality", "Delta"); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + mp = opentelemetry.sdk.metrics.MeterProvider(reader); setMeterProvider(mp); metername = "foo"; @@ -554,7 +558,7 @@ function testGetSetMeterProvider(testCase) % add value and attributes c.add(val); - pause(75); + pause(2.5); % perform test comparisons results = readJsonResults(testCase); From f9b7c45509806bccbfa995526e5b19be8ed94ca1 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 12 Oct 2023 11:30:46 -0400 Subject: [PATCH 22/40] clearning meter provider in test --- test/tmetrics.m | 1 + 1 file changed, 1 insertion(+) diff --git a/test/tmetrics.m b/test/tmetrics.m index 7284858..cdfea19 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -561,6 +561,7 @@ function testGetSetMeterProvider(testCase) pause(2.5); % perform test comparisons + clear p; results = readJsonResults(testCase); results = results{1}; % check a counter has been created, and check its resource to identify the From 39e01fa3ea061437837d3fb8defcbaff0211b4c9 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 12 Oct 2023 11:36:13 -0400 Subject: [PATCH 23/40] fixing typo --- test/tmetrics.m | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/tmetrics.m b/test/tmetrics.m index cdfea19..31b3b72 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -561,7 +561,7 @@ function testGetSetMeterProvider(testCase) pause(2.5); % perform test comparisons - clear p; + clear mp; results = readJsonResults(testCase); results = results{1}; % check a counter has been created, and check its resource to identify the From a630aa77d999a6461e5be54f3b7685fcf139c574 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 12 Oct 2023 14:39:12 -0400 Subject: [PATCH 24/40] Addressing PR comments --- api/metrics/+opentelemetry/+metrics/getMeter.m | 17 +++++++++++++++++ .../metrics/MeterProviderProxy.h | 3 --- .../+sdk/+metrics/MeterProvider.m | 17 +++-------------- test/tmetrics.m | 2 +- 4 files changed, 21 insertions(+), 18 deletions(-) create mode 100644 api/metrics/+opentelemetry/+metrics/getMeter.m diff --git a/api/metrics/+opentelemetry/+metrics/getMeter.m b/api/metrics/+opentelemetry/+metrics/getMeter.m new file mode 100644 index 0000000..7bd3efb --- /dev/null +++ b/api/metrics/+opentelemetry/+metrics/getMeter.m @@ -0,0 +1,17 @@ +function meter = getMeter(mname, varargin) +% Create a meter from the global meter provider instance +% M = OPENTELEMETRY.METRICS.GETMETER(NAME) returns a meter with the +% specified name created from the global meter provider instance. +% +% M = OPENTELEMETRY.METRICS.GETMETER(NAME, VERSION, SCHEMA) also +% specifies the meter version and the URL that documents the schema +% of the generated metrics. +% +% See also OPENTELEMETRY.SDK.METRICS.METERPROVIDER, +% OPENTELEMETRY.METRICS.METER, +% OPENTELEMETRY.METRICS.PROVIDER.SETMETERPROVIDER + +% Copyright 2023 The MathWorks, Inc. + +provider = opentelemetry.metrics.Provider.getMeterProvider(); +meter = getMeter(provider, mname, varargin{:}); diff --git a/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h b/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h index 947b0c9..8ff1dd8 100644 --- a/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h +++ b/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h @@ -13,10 +13,7 @@ #include "opentelemetry/metrics/noop.h" namespace metrics_api = opentelemetry::metrics; -namespace metrics_sdk = opentelemetry::sdk::metrics; -namespace metrics_exporter = opentelemetry::exporter::otlp; namespace nostd = opentelemetry::nostd; -namespace resource = opentelemetry::sdk::resource; namespace libmexclass::opentelemetry { class MeterProviderProxy : public libmexclass::proxy::Proxy { diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 58a5c72..c6c780e 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -4,11 +4,6 @@ % Copyright 2023 The MathWorks, Inc. - properties (Access=private) - isShutdown (1,1) logical = false - end - - properties (Access=public) MetricReader end @@ -38,6 +33,9 @@ "libmexclass.proxy.Proxy"])} = ... opentelemetry.sdk.metrics.PeriodicExportingMetricReader() end + + % explicit call to superclass constructor to make it a no-op + obj@opentelemetry.metrics.MeterProvider("skip"); obj.Proxy = libmexclass.proxy.Proxy("Name", ... "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... @@ -53,15 +51,6 @@ function addMetricReader(obj, reader) obj.Proxy.addMetricReader(reader.Proxy.ID); obj.MetricReader = [obj.MetricReader, reader]; end - - function success = shutdown(obj) - if ~obj.isShutdown - success = obj.Proxy.shutdown(); - obj.isShutdown = success; - else - success = true; - end - end end end diff --git a/test/tmetrics.m b/test/tmetrics.m index 31b3b72..f3a6398 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -549,7 +549,7 @@ function testGetSetMeterProvider(testCase) metername = "foo"; countername = "bar"; - m = getMeter(mp, metername); + m = opentelemetry.metrics.getMeter(metername); c = createCounter(m, countername); % create testing value From fd75583d87ed801d80ade0087d71d01e2fbe7a00 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 12 Oct 2023 15:46:21 -0400 Subject: [PATCH 25/40] Fixing crash and comment out test --- .../sdk/metrics/MeterProviderProxy.h | 5 +- test/tmetrics.m | 65 +++++++++---------- 2 files changed, 33 insertions(+), 37 deletions(-) diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h index 37a8d57..9412a7a 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h @@ -35,15 +35,12 @@ namespace otlpexporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::sdk { class MeterProviderProxy : public libmexclass::opentelemetry::MeterProviderProxy { public: - MeterProviderProxy(nostd::shared_ptr mp) : libmexclass::opentelemetry::MeterProviderProxy(mp), CppMeterProvider(mp) { + MeterProviderProxy(nostd::shared_ptr mp) : libmexclass::opentelemetry::MeterProviderProxy(mp) { REGISTER_METHOD(MeterProviderProxy, addMetricReader); } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); void addMetricReader(libmexclass::proxy::method::Context& context); - - protected: - nostd::shared_ptr CppMeterProvider; }; } // namespace libmexclass::opentelemetry diff --git a/test/tmetrics.m b/test/tmetrics.m index f3a6398..3cfa779 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -538,39 +538,38 @@ function testHistogramDelta(testCase) end end - function testGetSetMeterProvider(testCase) - % testGetSetMeterProvider: setting and getting global instance of MeterProvider - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... - "PreferredAggregationTemporality", "Delta"); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - mp = opentelemetry.sdk.metrics.MeterProvider(reader); - setMeterProvider(mp); - - metername = "foo"; - countername = "bar"; - m = opentelemetry.metrics.getMeter(metername); - c = createCounter(m, countername); - - % create testing value - val = 10; - - % add value and attributes - c.add(val); - - pause(2.5); - - % perform test comparisons - clear mp; - results = readJsonResults(testCase); - results = results{1}; - % check a counter has been created, and check its resource to identify the - % correct MeterProvider has been used - verifyNotEmpty(testCase, results); - - verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.metrics.name), countername); - verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.scope.name), metername); - end + % function testGetSetMeterProvider(testCase) + % % testGetSetMeterProvider: setting and getting global instance of MeterProvider + % exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + % reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + % "Interval", seconds(2), "Timeout", seconds(1)); + % mp = opentelemetry.sdk.metrics.MeterProvider(reader); + % setMeterProvider(mp); + % + % metername = "foo"; + % countername = "bar"; + % m = opentelemetry.metrics.getMeter(metername); + % c = createCounter(m, countername); + % + % % create testing value + % val = 10; + % + % % add value and attributes + % c.add(val); + % + % pause(2.5); + % + % % perform test comparisons + % clear mp; + % results = readJsonResults(testCase); + % results = results{1}; + % % check a counter has been created, and check its resource to identify the + % % correct MeterProvider has been used + % verifyNotEmpty(testCase, results); + % + % verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.metrics.name), countername); + % verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.scope.name), metername); + % end end From ff030aeb1c12f5ea26a6b1f550cc31bb31a5bb05 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 26 Oct 2023 15:44:54 -0400 Subject: [PATCH 26/40] Adding shutdown and forceflush to fix getsetmeterprovider test --- .../+opentelemetry/+metrics/MeterProvider.m | 9 ++- .../metrics/MeterProviderProxy.h | 7 ++ .../+opentelemetry/+sdk/+metrics/Cleanup.m | 63 ++++++++++++++++++ .../+sdk/+metrics/MeterProvider.m | 58 ++++++++++++++-- .../sdk/metrics/MeterProviderProxy.h | 6 ++ sdk/metrics/src/MeterProviderProxy.cpp | 59 +++++++++++++---- test/commonSetup.m | 2 +- test/tmetrics.m | 66 ++++++++++--------- 8 files changed, 219 insertions(+), 51 deletions(-) create mode 100644 sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m diff --git a/api/metrics/+opentelemetry/+metrics/MeterProvider.m b/api/metrics/+opentelemetry/+metrics/MeterProvider.m index ec3b615..bfb8a3b 100644 --- a/api/metrics/+opentelemetry/+metrics/MeterProvider.m +++ b/api/metrics/+opentelemetry/+metrics/MeterProvider.m @@ -4,7 +4,7 @@ % Copyright 2023 The MathWorks, Inc. - properties (Access={?opentelemetry.sdk.metrics.MeterProvider}) + properties (Access={?opentelemetry.sdk.metrics.MeterProvider, ?opentelemetry.sdk.metrics.Cleanup}) Proxy % Proxy object to interface C++ code end @@ -59,4 +59,11 @@ function setMeterProvider(obj) obj.Proxy.setMeterProvider(); end end + + methods(Access=?opentelemetry.sdk.metrics.Cleanup) + function postShutdown(obj) + % POSTSHUTDOWN Handle post-shutdown tasks + obj.Proxy.postShutdown(); + end + end end diff --git a/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h b/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h index 8ff1dd8..0e00b1e 100644 --- a/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h +++ b/api/metrics/include/opentelemetry-matlab/metrics/MeterProviderProxy.h @@ -21,6 +21,7 @@ class MeterProviderProxy : public libmexclass::proxy::Proxy { MeterProviderProxy(nostd::shared_ptr mp) : CppMeterProvider(mp) { REGISTER_METHOD(MeterProviderProxy, getMeter); REGISTER_METHOD(MeterProviderProxy, setMeterProvider); + REGISTER_METHOD(MeterProviderProxy, postShutdown); } // Static make method should only be used by getMeterProvider. It gets the global instance @@ -36,6 +37,12 @@ class MeterProviderProxy : public libmexclass::proxy::Proxy { nostd::shared_ptr getInstance() { return CppMeterProvider; } + + void postShutdown(libmexclass::proxy::method::Context& context) { + // Replace meter provider with a no-op instance. Subsequent metrics won't be recorded + nostd::shared_ptr noop(new metrics_api::NoopMeterProvider); + CppMeterProvider.swap(noop); + } protected: nostd::shared_ptr CppMeterProvider; diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m new file mode 100644 index 0000000..ea84591 --- /dev/null +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m @@ -0,0 +1,63 @@ +classdef Cleanup +% Clean up methods for MeterProvider in the API + +% Copyright 2023 The MathWorks, Inc. + + methods (Static) + function success = shutdown(mp) + % SHUTDOWN Shutdown + % SUCCESS = SHUTDOWN(MP) shuts down all span processors associated with + % API meter provider MP and return a logical that indicates + % whether shutdown was successful. + % + % See also FORCEFLUSH + + % return false if input is not the right type + if isa(mp, "opentelemetry.metrics.MeterProvider") + % convert to MeterProvider class in sdk + try + mpsdk = opentelemetry.sdk.metrics.MeterProvider(mp.Proxy); + catch + success = false; + return + end + success = mpsdk.shutdown; + postShutdown(mp); + else + success = false; + end + end + + function success = forceFlush(mp, timeout) + % FORCEFLUSH Force flush + % SUCCESS = FORCEFLUSH(MP) immediately exports all spans + % that have not yet been exported. Returns a logical that + % indicates whether force flush was successful. + % + % SUCCESS = FORCEFLUSH(MP, TIMEOUT) specifies a TIMEOUT + % duration. Force flush must be completed within this time, + % or else it will fail. + % + % See also SHUTDOWN + + % return false if input is not the right type + if isa(mp, "opentelemetry.metrics.MeterProvider") + % convert to MeterProvider class in sdk + try + mpsdk = opentelemetry.sdk.metrics.MeterProvider(mp.Proxy); + catch + success = false; + return + end + if nargin < 2 || ~isa(timeout, "duration") + success = mpsdk.forceFlush; + else + success = mpsdk.forceFlush(timeout); + end + else + success = false; + end + end + end + +end diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index c6c780e..60d3ab3 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -4,6 +4,10 @@ % Copyright 2023 The MathWorks, Inc. + properties(Access=private) + isShutdown (1,1) logical = false + end + properties (Access=public) MetricReader end @@ -37,10 +41,22 @@ % explicit call to superclass constructor to make it a no-op obj@opentelemetry.metrics.MeterProvider("skip"); - obj.Proxy = libmexclass.proxy.Proxy("Name", ... - "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... - "ConstructorArguments", {reader.Proxy.ID}); - obj.MetricReader = reader; + if isa(reader, "libmexclass.proxy.Proxy") + % This code branch is used to support conversion from API + % MeterProvider to SDK equivalent, needed internally by + % opentelemetry.sdk.metrics.Cleanup + mpproxy = reader; % rename the variable + % assert(mpproxy.Name == "libmexclass.opentelemetry.MeterProviderProxy"); + obj.Proxy = libmexclass.proxy.Proxy("Name", ... + "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... + "ConstructorArguments", {mpproxy.ID}); + % leave other properties unassigned, they won't be used + else + obj.Proxy = libmexclass.proxy.Proxy("Name", ... + "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... + "ConstructorArguments", {reader.Proxy.ID, 0}); + obj.MetricReader = reader; + end end function addMetricReader(obj, reader) @@ -52,5 +68,39 @@ function addMetricReader(obj, reader) obj.MetricReader = [obj.MetricReader, reader]; end + function success = shutdown(obj) + % SHUTDOWN Shutdown + % SUCCESS = SHUTDOWN(MP) shuts down all span processors associated with meter provider MP + % and return a logical that indicates whether shutdown was successful. + % + % See also FORCEFLUSH + if ~obj.isShutdown + success = obj.Proxy.shutdown(); + obj.isShutdown = success; + else + success = true; + end + end + + function success = forceFlush(obj, timeout) + % FORCEFLUSH Force flush + % SUCCESS = FORCEFLUSH(MP) immediately exports all spans + % that have not yet been exported. Returns a logical that + % indicates whether force flush was successful. + % + % SUCCESS = FORCEFLUSH(MP, TIMEOUT) specifies a TIMEOUT + % duration. Force flush must be completed within this time, + % or else it will fail. + % + % See also SHUTDOWN + if obj.isShutdown + success = false; + elseif nargin < 2 || ~isa(timeout, "duration") % ignore timeout if not a duration + success = obj.Proxy.forceFlush(); + else + success = obj.Proxy.forceFlush(milliseconds(timeout)*1000); % convert to microseconds + end + end + end end diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h index 9412a7a..53a5dee 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h @@ -37,10 +37,16 @@ class MeterProviderProxy : public libmexclass::opentelemetry::MeterProviderProxy public: MeterProviderProxy(nostd::shared_ptr mp) : libmexclass::opentelemetry::MeterProviderProxy(mp) { REGISTER_METHOD(MeterProviderProxy, addMetricReader); + REGISTER_METHOD(MeterProviderProxy, shutdown); + REGISTER_METHOD(MeterProviderProxy, forceFlush); } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); void addMetricReader(libmexclass::proxy::method::Context& context); + + void shutdown(libmexclass::proxy::method::Context& context); + + void forceFlush(libmexclass::proxy::method::Context& context); }; } // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index 7b57f09..16eae65 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -11,19 +11,32 @@ namespace libmexclass::opentelemetry::sdk { libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { libmexclass::proxy::MakeResult out; - - matlab::data::TypedArray readerid_mda = constructor_arguments[0]; - libmexclass::proxy::ID readerid = readerid_mda[0]; - - auto reader = std::static_pointer_cast( - libmexclass::proxy::ProxyManager::getProxy(readerid))->getInstance(); - auto p = metrics_sdk::MeterProviderFactory::Create(); - auto *p_sdk = static_cast(p.get()); - p_sdk->AddMetricReader(std::move(reader)); - - auto p_out = nostd::shared_ptr(std::move(p)); - out = std::make_shared(p_out); - + if (constructor_arguments.getNumberOfElements() == 1) { + // if argument is 1, assume it is an API Meter Provider to support type conversion + matlab::data::TypedArray mpid_mda = constructor_arguments[0]; + libmexclass::proxy::ID mpid = mpid_mda[0]; + auto mp = std::static_pointer_cast( + libmexclass::proxy::ProxyManager::getProxy(mpid))->getInstance(); + // check if input can be cast to an SDK Meter Provider + auto mpsdk = dynamic_cast(mp.get()); + if (mpsdk == nullptr) { + return libmexclass::error::Error{"opentelemetry:sdk:metrics:Cleanup:UnsetGlobalInstance", + "Clean up operations are not supported if global MeterProvider instance is not set."}; + } + out = std::make_shared(nostd::shared_ptr(mp)); + } else { + matlab::data::TypedArray readerid_mda = constructor_arguments[0]; + libmexclass::proxy::ID readerid = readerid_mda[0]; + + auto reader = std::static_pointer_cast( + libmexclass::proxy::ProxyManager::getProxy(readerid))->getInstance(); + auto p = metrics_sdk::MeterProviderFactory::Create(); + auto *p_sdk = static_cast(p.get()); + p_sdk->AddMetricReader(std::move(reader)); + + auto p_out = nostd::shared_ptr(std::move(p)); + out = std::make_shared(p_out); + } return out; } @@ -37,5 +50,25 @@ void MeterProviderProxy::addMetricReader(libmexclass::proxy::method::Context& co return; } +void MeterProviderProxy::shutdown(libmexclass::proxy::method::Context& context) { + matlab::data::ArrayFactory factory; + auto result_mda = factory.createScalar(static_cast(*CppMeterProvider).Shutdown()); + context.outputs[0] = result_mda; + nostd::shared_ptr noop(new metrics_api::NoopMeterProvider); + CppMeterProvider.swap(noop); +} + +void MeterProviderProxy::forceFlush(libmexclass::proxy::method::Context& context) { + matlab::data::ArrayFactory factory; + + if (context.inputs.getNumberOfElements() == 0) { + context.outputs[0] = factory.createScalar(static_cast(*CppMeterProvider).ForceFlush()); + } else { // number of inputs > 0 + matlab::data::TypedArray timeout_mda = context.inputs[0]; + auto timeout = std::chrono::microseconds(timeout_mda[0]); + context.outputs[0] = factory.createScalar(static_cast(*CppMeterProvider).ForceFlush(timeout)); + } +} + } // namespace libmexclass::opentelemetry diff --git a/test/commonSetup.m b/test/commonSetup.m index 98d1fa8..667b3ac 100644 --- a/test/commonSetup.m +++ b/test/commonSetup.m @@ -4,5 +4,5 @@ function commonSetup(testCase) % Copyright 2023 The MathWorks, Inc. % start collector -system(testCase.Otelcol + " --config " + testCase.OtelConfigFile + '&'); +system(testCase.Otelcol + " --config " + '"' + testCase.OtelConfigFile + '"' + '&'); pause(1); % give a little time for Collector to start up \ No newline at end of file diff --git a/test/tmetrics.m b/test/tmetrics.m index 3cfa779..a64b128 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -538,38 +538,40 @@ function testHistogramDelta(testCase) end end - % function testGetSetMeterProvider(testCase) - % % testGetSetMeterProvider: setting and getting global instance of MeterProvider - % exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - % reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - % "Interval", seconds(2), "Timeout", seconds(1)); - % mp = opentelemetry.sdk.metrics.MeterProvider(reader); - % setMeterProvider(mp); - % - % metername = "foo"; - % countername = "bar"; - % m = opentelemetry.metrics.getMeter(metername); - % c = createCounter(m, countername); - % - % % create testing value - % val = 10; - % - % % add value and attributes - % c.add(val); - % - % pause(2.5); - % - % % perform test comparisons - % clear mp; - % results = readJsonResults(testCase); - % results = results{1}; - % % check a counter has been created, and check its resource to identify the - % % correct MeterProvider has been used - % verifyNotEmpty(testCase, results); - % - % verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.metrics.name), countername); - % verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.scope.name), metername); - % end + function testGetSetMeterProvider(testCase) + % testGetSetMeterProvider: setting and getting global instance of MeterProvider + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + mp = opentelemetry.sdk.metrics.MeterProvider(reader); + setMeterProvider(mp); + + metername = "foo"; + countername = "bar"; + m = opentelemetry.metrics.getMeter(metername); + c = createCounter(m, countername); + + % create testing value + val = 10; + + % add value and attributes + c.add(val); + + pause(2.5); + + % perform test comparisons + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(mp)); + clear mp; + + results = readJsonResults(testCase); + results = results{1}; + % check a counter has been created, and check its resource to identify the + % correct MeterProvider has been used + verifyNotEmpty(testCase, results); + + verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.metrics.name), countername); + verifyEqual(testCase, string(results.resourceMetrics.scopeMetrics.scope.name), metername); + end end From e1c58c4b623b94c87d1f96140e1a11868f88f98b Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Mon, 30 Oct 2023 13:23:22 -0400 Subject: [PATCH 27/40] Clean up code and finish shutdown --- .../+sdk/+metrics/MeterProvider.m | 4 ++-- sdk/metrics/src/MeterProviderProxy.cpp | 3 ++- test/tmetrics.m | 24 +++++++++---------- 3 files changed, 16 insertions(+), 15 deletions(-) diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 60d3ab3..646a078 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -49,12 +49,12 @@ % assert(mpproxy.Name == "libmexclass.opentelemetry.MeterProviderProxy"); obj.Proxy = libmexclass.proxy.Proxy("Name", ... "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... - "ConstructorArguments", {mpproxy.ID}); + "ConstructorArguments", {mpproxy.ID, true}); % leave other properties unassigned, they won't be used else obj.Proxy = libmexclass.proxy.Proxy("Name", ... "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... - "ConstructorArguments", {reader.Proxy.ID, 0}); + "ConstructorArguments", {reader.Proxy.ID, false}); obj.MetricReader = reader; end end diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index 16eae65..e3f5f28 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -11,7 +11,8 @@ namespace libmexclass::opentelemetry::sdk { libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { libmexclass::proxy::MakeResult out; - if (constructor_arguments.getNumberOfElements() == 1) { + matlab::data::TypedArray is_api = constructor_arguments[1]; + if (is_api[0]) { // if argument is 1, assume it is an API Meter Provider to support type conversion matlab::data::TypedArray mpid_mda = constructor_arguments[0]; libmexclass::proxy::ID mpid = mpid_mda[0]; diff --git a/test/tmetrics.m b/test/tmetrics.m index a64b128..99587d4 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -101,7 +101,7 @@ function testAddMetricReader(testCase) % adding a single value ct.add(1); pause(2.5); - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); result_count = numel(results); verifyEqual(testCase,result_count, 2); @@ -136,7 +136,7 @@ function testCounterBasic(testCase) pause(2.5); % fetch result - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); results = results{end}; @@ -180,7 +180,7 @@ function testCounterDelta(testCase) % fetch results pause(2.5); - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); dp1 = results{1}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; dp2 = results{2}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -219,7 +219,7 @@ function testCounterAddAttributes(testCase) pause(2.5); % fetch result - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); results = results{end}; @@ -263,7 +263,7 @@ function testCounterAddNegative(testCase) pause(2.5); % fetch results - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -303,7 +303,7 @@ function testUpDownCounterBasic(testCase) pause(5); % fetch result - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); results = results{end}; @@ -348,7 +348,7 @@ function testUpDownCounterAddAttributes(testCase) pause(5); % fetch result - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -397,7 +397,7 @@ function testHistogramBasic(testCase) pause(10); % fetch results - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; @@ -454,7 +454,7 @@ function testHistogramRecordAttributes(testCase) pause(10); % fetch results - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; @@ -511,7 +511,7 @@ function testHistogramDelta(testCase) pause(2.5); % fetch results - clear p; + verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); results = readJsonResults(testCase); rsize = size(results); for i = 1:rsize(2) @@ -559,10 +559,10 @@ function testGetSetMeterProvider(testCase) pause(2.5); - % perform test comparisons + %Shutdown the Meter Provider verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(mp)); - clear mp; + % perform test comparisons results = readJsonResults(testCase); results = results{1}; % check a counter has been created, and check its resource to identify the From e245e2e69544c2e51dc414f21c8594a1279e1306 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Mon, 30 Oct 2023 13:30:07 -0400 Subject: [PATCH 28/40] Removing unnecessary change in tests --- test/commonSetup.m | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/commonSetup.m b/test/commonSetup.m index 667b3ac..98d1fa8 100644 --- a/test/commonSetup.m +++ b/test/commonSetup.m @@ -4,5 +4,5 @@ function commonSetup(testCase) % Copyright 2023 The MathWorks, Inc. % start collector -system(testCase.Otelcol + " --config " + '"' + testCase.OtelConfigFile + '"' + '&'); +system(testCase.Otelcol + " --config " + testCase.OtelConfigFile + '&'); pause(1); % give a little time for Collector to start up \ No newline at end of file From caab36ba90b81fa8df7f382b765b077d97019773 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Tue, 31 Oct 2023 15:14:50 -0400 Subject: [PATCH 29/40] Addressing pull request comments --- .../+opentelemetry/+sdk/+metrics/Cleanup.m | 4 ++-- .../+sdk/+metrics/MeterProvider.m | 6 ++--- test/tmetrics.m | 22 +++++++++---------- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m index ea84591..0f31c4b 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m @@ -6,7 +6,7 @@ methods (Static) function success = shutdown(mp) % SHUTDOWN Shutdown - % SUCCESS = SHUTDOWN(MP) shuts down all span processors associated with + % SUCCESS = SHUTDOWN(MP) shuts down all metric readers associated with % API meter provider MP and return a logical that indicates % whether shutdown was successful. % @@ -30,7 +30,7 @@ function success = forceFlush(mp, timeout) % FORCEFLUSH Force flush - % SUCCESS = FORCEFLUSH(MP) immediately exports all spans + % SUCCESS = FORCEFLUSH(MP) immediately exports all metrics % that have not yet been exported. Returns a logical that % indicates whether force flush was successful. % diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 646a078..7c47bd0 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -46,7 +46,7 @@ % MeterProvider to SDK equivalent, needed internally by % opentelemetry.sdk.metrics.Cleanup mpproxy = reader; % rename the variable - % assert(mpproxy.Name == "libmexclass.opentelemetry.MeterProviderProxy"); + assert(mpproxy.Name == "libmexclass.opentelemetry.MeterProviderProxy"); obj.Proxy = libmexclass.proxy.Proxy("Name", ... "libmexclass.opentelemetry.sdk.MeterProviderProxy", ... "ConstructorArguments", {mpproxy.ID, true}); @@ -70,7 +70,7 @@ function addMetricReader(obj, reader) function success = shutdown(obj) % SHUTDOWN Shutdown - % SUCCESS = SHUTDOWN(MP) shuts down all span processors associated with meter provider MP + % SUCCESS = SHUTDOWN(MP) shuts down all metric readers associated with meter provider MP % and return a logical that indicates whether shutdown was successful. % % See also FORCEFLUSH @@ -84,7 +84,7 @@ function addMetricReader(obj, reader) function success = forceFlush(obj, timeout) % FORCEFLUSH Force flush - % SUCCESS = FORCEFLUSH(MP) immediately exports all spans + % SUCCESS = FORCEFLUSH(MP) immediately exports all metrics % that have not yet been exported. Returns a logical that % indicates whether force flush was successful. % diff --git a/test/tmetrics.m b/test/tmetrics.m index 99587d4..9cecbf9 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -101,7 +101,7 @@ function testAddMetricReader(testCase) % adding a single value ct.add(1); pause(2.5); - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); result_count = numel(results); verifyEqual(testCase,result_count, 2); @@ -136,7 +136,7 @@ function testCounterBasic(testCase) pause(2.5); % fetch result - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); results = results{end}; @@ -180,7 +180,7 @@ function testCounterDelta(testCase) % fetch results pause(2.5); - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); dp1 = results{1}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; dp2 = results{2}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -219,7 +219,7 @@ function testCounterAddAttributes(testCase) pause(2.5); % fetch result - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); results = results{end}; @@ -263,7 +263,7 @@ function testCounterAddNegative(testCase) pause(2.5); % fetch results - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -303,7 +303,7 @@ function testUpDownCounterBasic(testCase) pause(5); % fetch result - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); results = results{end}; @@ -348,7 +348,7 @@ function testUpDownCounterAddAttributes(testCase) pause(5); % fetch result - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -397,7 +397,7 @@ function testHistogramBasic(testCase) pause(10); % fetch results - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; @@ -454,7 +454,7 @@ function testHistogramRecordAttributes(testCase) pause(10); % fetch results - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; @@ -511,7 +511,7 @@ function testHistogramDelta(testCase) pause(2.5); % fetch results - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(p)); + verifyTrue(testCase, p.shutdown()); results = readJsonResults(testCase); rsize = size(results); for i = 1:rsize(2) @@ -560,7 +560,7 @@ function testGetSetMeterProvider(testCase) pause(2.5); %Shutdown the Meter Provider - verifyTrue(testCase, opentelemetry.sdk.metrics.Cleanup.shutdown(mp)); + verifyTrue(testCase, mp.shutdown()); % perform test comparisons results = readJsonResults(testCase); From f3884c379818b6a2e23dbe90d714a2d8fc44d77d Mon Sep 17 00:00:00 2001 From: duncanpo Date: Thu, 2 Nov 2023 12:14:00 -0400 Subject: [PATCH 30/40] Make metric reader and exporter properties editable --- .../+exporters/+otlp/OtlpGrpcMetricExporter.m | 159 ++++++++---------- .../+exporters/+otlp/OtlpHttpMetricExporter.m | 151 +++++++---------- .../otlp/OtlpGrpcMetricExporterProxy.h | 16 +- .../otlp/OtlpHttpMetricExporterProxy.h | 16 +- .../otlp/src/OtlpGrpcMetricExporterProxy.cpp | 126 +++++++------- .../otlp/src/OtlpHttpMetricExporterProxy.cpp | 141 ++++++---------- .../+sdk/+metrics/MetricExporter.m | 4 +- .../+metrics/PeriodicExportingMetricReader.m | 61 +++---- .../PeriodicExportingMetricReaderProxy.h | 6 +- .../PeriodicExportingMetricReaderProxy.cpp | 37 ++-- test/tmetrics.m | 10 +- 11 files changed, 323 insertions(+), 404 deletions(-) diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m index edc7078..5d195fd 100644 --- a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpGrpcMetricExporter.m @@ -5,14 +5,14 @@ % Copyright 2023 The MathWorks, Inc. - properties (SetAccess=immutable) - Endpoint (1,1) string % Export destination - UseCredentials (1,1) logical % Whether to use SSL credentials - CertificatePath (1,1) string % Path to .pem file for SSL encryption - CertificateString (1,1) string % In-memory string representation of .pem file for SSL encryption - Timeout (1,1) duration % Maximum time above which exports will abort - HttpHeaders (1,1) dictionary % Additional HTTP headers - PreferredAggregationTemporality (1,1) string % Preferred Aggregation Temporality + properties + Endpoint (1,1) string = "http://localhost:4317" % Export destination + UseCredentials (1,1) logical = false % Whether to use SSL credentials + CertificatePath (1,1) string = "" % Path to .pem file for SSL encryption + CertificateString (1,1) string = "" % In-memory string representation of .pem file for SSL encryption + Timeout (1,1) duration = seconds(10) % Maximum time above which exports will abort + HttpHeaders (1,1) dictionary = dictionary(string.empty, string.empty) % Additional HTTP headers + PreferredAggregationTemporality (1,1) string = "cumulative" % Preferred Aggregation Temporality end methods @@ -47,100 +47,79 @@ optionvalues end + obj = obj@opentelemetry.sdk.metrics.MetricExporter(... + "libmexclass.opentelemetry.exporters.OtlpGrpcMetricExporterProxy"); + validnames = ["Endpoint", "UseCredentials ", "CertificatePath", ... "CertificateString", "Timeout", "HttpHeaders", "PreferredAggregationTemporality"]; - % set default values to empty or negative - endpoint = ""; - usessl = false; - certificatepath = ""; - certificatestring = ""; - timeout_millis = -1; - headerkeys = string.empty(); - headervalues = string.empty(); - temporality = ""; for i = 1:length(optionnames) namei = validatestring(optionnames{i}, validnames); valuei = optionvalues{i}; - if strcmp(namei, "Endpoint") - if ~(isStringScalar(valuei) || (ischar(valuei) && isrow(valuei))) - error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:EndpointNotScalarText", "Endpoint must be a scalar string."); - end - endpoint = string(valuei); - elseif strcmp(namei, "UseCredentials ") - if ~((islogical(valuei) || isnumeric(valuei)) && isscalar(valuei)) - error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:UseCredentialsNotScalarLogical", "UseCredentials must be a scalar logical.") - end - usessl = logical(valuei); - elseif strcmp(namei, "CertificatePath") - if ~(isStringScalar(valuei) || (ischar(valuei) && isrow(valuei))) - error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:CertificatePathNotScalarText", "CertificatePath must be a scalar string."); - end - certificatepath = string(valuei); - elseif strcmp(namei, "CertificateString") - if ~(isStringScalar(valuei) || (ischar(valuei) && isrow(valuei))) - error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:CertificateStringNotScalarText", "CertificateString must be a scalar string."); - end - certificatestring = string(valuei); - elseif strcmp(namei, "Timeout") - if ~(isduration(valuei) && isscalar(valuei)) - error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:TimeoutNotScalarDuration", "Timeout must be a scalar duration."); - end - timeout = valuei; - timeout_millis = milliseconds(timeout); - elseif strcmp(namei, "HttpHeaders") % HttpHeaders - if ~isa(valuei, "dictionary") - error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:HttpHeadersNotDictionary", "HttpHeaders input must be a dictionary."); - end - httpheaders = valuei; - headerkeys = keys(valuei); - headervalues = values(valuei); - if ~isstring(headervalues) - error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:HttpHeadersNonStringValues", "HttpHeaders dictionary values must be strings.") - end - elseif strcmp(namei, "PreferredAggregationTemporality") - temporality = validatestring(valuei, ["Cumulative", "Delta"]); - end + obj.(namei) = valuei; end - - obj = obj@opentelemetry.sdk.metrics.MetricExporter(... - "libmexclass.opentelemetry.exporters.OtlpGrpcMetricExporterProxy", ... - endpoint, usessl, certificatepath, certificatestring, ... - timeout_millis, headerkeys, headervalues, temporality); + end + + function obj = set.Endpoint(obj, ep) + if ~(isStringScalar(ep) || (ischar(ep) && isrow(ep))) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:EndpointNotScalarText", "Endpoint must be a scalar string."); + end + ep = string(ep); + obj.Proxy.setEndpoint(ep); + obj.Endpoint = ep; + end + + function obj = set.UseCredentials(obj, uc) + if ~((islogical(uc) || isnumeric(uc)) && isscalar(uc)) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:UseCredentialsNotScalarLogical", "UseCredentials must be a scalar logical.") + end + uc = logical(uc); + obj.Proxy.setUseCredentials(uc); + obj.UseCredentials = uc; + end - % populate immutable properties - [defaultendpoint, defaultcertpath, defaultcertstring, defaultmillis, defaulttemporality] = ... - getDefaultOptionValues(obj); - if endpoint == "" % not specified, use default value - obj.Endpoint = defaultendpoint; - else - obj.Endpoint = endpoint; - end - obj.UseCredentials = usessl; - if certificatepath == "" % not specified, use default value - obj.CertificatePath = defaultcertpath; - else - obj.CertificatePath = certificatepath; + function obj = set.CertificatePath(obj, certpath) + if ~(isStringScalar(certpath) || (ischar(certpath) && isrow(certpath))) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:CertificatePathNotScalarText", "CertificatePath must be a scalar string."); end - if certificatestring == "" % not specified, use default value - obj.CertificateString = defaultcertstring; - else - obj.CertificateString = certificatestring; + certpath = string(certpath); + obj.Proxy.setCertificatePath(certpath); + obj.CertificatePath = certpath; + end + + function obj = set.CertificateString(obj, certstr) + if ~(isStringScalar(certstr) || (ischar(certstr) && isrow(certstr))) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:CertificateStringNotScalarText", "CertificateString must be a scalar string."); end - if timeout_millis < 0 % not specified, use default value - obj.Timeout = milliseconds(defaultmillis); - else - obj.Timeout = timeout; + certstr = string(certstr); + obj.Proxy.setCertificateString(certstr); + obj.CertificateString = certstr; + end + + function obj = set.Timeout(obj, timeout) + if ~(isduration(timeout) && isscalar(timeout)) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:TimeoutNotScalarDuration", "Timeout must be a scalar duration."); end - if isempty(headerkeys) % not specified, return empty dictionary - obj.HttpHeaders = dictionary(headerkeys, headervalues); - else - obj.HttpHeaders = httpheaders; + obj.Proxy.setTimeout(milliseconds(timeout)); + obj.Timeout = timeout; + end + + function obj = set.HttpHeaders(obj, httpheaders) + if ~isa(httpheaders, "dictionary") + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:HttpHeadersNotDictionary", "HttpHeaders input must be a dictionary."); end - if temporality == "" - obj.PreferredAggregationTemporality = defaulttemporality; - else - obj.PreferredAggregationTemporality = temporality; + headerkeys = keys(httpheaders); + headervalues = values(httpheaders); + if ~isstring(headervalues) + error("opentelemetry:exporters:otlp:OtlpGrpcMetricExporter:HttpHeadersNonStringValues", "HttpHeaders dictionary values must be strings.") end + obj.Proxy.setHttpHeaders(headerkeys, headervalues); + obj.HttpHeaders = httpheaders; + end + + function obj = set.PreferredAggregationTemporality(obj, temporality) + temporality = validatestring(temporality, ["cumulative", "delta"]); + obj.Proxy.setTemporality(temporality); + obj.PreferredAggregationTemporality = temporality; end end end diff --git a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m index 10e1f3b..490c468 100644 --- a/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m +++ b/exporters/otlp/+opentelemetry/+exporters/+otlp/OtlpHttpMetricExporter.m @@ -5,14 +5,14 @@ % Copyright 2023 The MathWorks, Inc. - properties (SetAccess=immutable) - Endpoint (1,1) string % Export destination - Format (1,1) string % Data format, JSON or binary - JsonBytesMapping (1,1) string % What to convert JSON bytes to - UseJsonName (1,1) logical % Whether to use JSON name of protobuf field to set the key of JSON - Timeout (1,1) duration % Maximum time above which exports will abort - HttpHeaders (1,1) dictionary % Additional HTTP headers - PreferredAggregationTemporality (1,1) string % Preferred Aggregation Temporality + properties + Endpoint (1,1) string = "http://localhost:4318/v1/metrics" % Export destination + Format (1,1) string = "JSON" % Data format, JSON or binary + JsonBytesMapping (1,1) string = "hexId" % What to convert JSON bytes to + UseJsonName (1,1) logical = false % Whether to use JSON name of protobuf field to set the key of JSON + Timeout (1,1) duration = seconds(10) % Maximum time above which exports will abort + HttpHeaders (1,1) dictionary = dictionary(string.empty, string.empty) % Additional HTTP headers + PreferredAggregationTemporality (1,1) string = "cumulative" % Preferred Aggregation Temporality end methods @@ -47,98 +47,73 @@ optionvalues end + obj = obj@opentelemetry.sdk.metrics.MetricExporter(... + "libmexclass.opentelemetry.exporters.OtlpHttpMetricExporterProxy"); + validnames = ["Endpoint", "Format", "JsonBytesMapping", ... "UseJsonName", "Timeout", "HttpHeaders", "PreferredAggregationTemporality"]; - % set default values to empty or negative - endpoint = ""; - dataformat = ""; - jsonbytesmapping = ""; - usejsonname = false; - timeout_millis = -1; - headerkeys = string.empty(); - headervalues = string.empty(); - temporality = ""; for i = 1:length(optionnames) namei = validatestring(optionnames{i}, validnames); valuei = optionvalues{i}; - if strcmp(namei, "Endpoint") - if ~(isStringScalar(valuei) || (ischar(valuei) && isrow(valuei))) - error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:EndpointNotScalarText", "Endpoint must be a scalar string."); - end - endpoint = string(valuei); - elseif strcmp(namei, "Format") - dataformat = validatestring(valuei, ["JSON", "binary"]); - elseif strcmp(namei, "JsonBytesMapping") - jsonbytesmapping = validatestring(valuei, ["hex", "hexId", "base64"]); - elseif strcmp(namei, "UseJsonName") - if ~((islogical(valuei) || isnumeric(valuei)) && isscalar(valuei)) - error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:UseJsonNameNotScalarLogical", "UseJsonName must be a scalar logical.") - end - usejsonname = logical(valuei); - elseif strcmp(namei, "Timeout") - if ~(isduration(valuei) && isscalar(valuei)) - error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:TimeoutNotScalarDuration", "Timeout must be a scalar duration."); - end - timeout = valuei; - timeout_millis = milliseconds(timeout); - elseif strcmp(namei, "HttpHeaders") - if ~isa(valuei, "dictionary") - error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:HttpHeadersNotDictionary", "HttpHeaders input must be a dictionary."); - end - httpheaders = valuei; - headerkeys = keys(valuei); - headervalues = values(valuei); - if ~isstring(headervalues) - error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:HttpHeadersNonStringValues", "HttpHeaders dictionary values must be strings.") - end - elseif strcmp(namei, "PreferredAggregationTemporality") - temporality = validatestring(valuei, ["Cumulative", "Delta"]); - end - + obj.(namei) = valuei; end - - obj = obj@opentelemetry.sdk.metrics.MetricExporter(... - "libmexclass.opentelemetry.exporters.OtlpHttpMetricExporterProxy", ... - endpoint, dataformat, jsonbytesmapping, usejsonname, ... - timeout_millis, headerkeys, headervalues, temporality); + end - % populate immutable properties - if endpoint == "" || dataformat == "" || jsonbytesmapping == "" || ... - timeout_millis < 0 - [defaultendpoint, defaultformat, defaultmapping, defaultmillis, defaulttemporality] = ... - getDefaultOptionValues(obj); - end - if endpoint == "" % not specified, use default value - obj.Endpoint = defaultendpoint; - else - obj.Endpoint = endpoint; + function obj = set.Endpoint(obj, ep) + if ~(isStringScalar(ep) || (ischar(ep) && isrow(ep))) + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:EndpointNotScalarText", "Endpoint must be a scalar string."); end - if dataformat == "" % not specified, use default value - obj.Format = defaultformat; - else - obj.Format = dataformat; - end - if jsonbytesmapping == "" % not specified, use default value - obj.JsonBytesMapping = defaultmapping; - else - obj.JsonBytesMapping = jsonbytesmapping; + ep = string(ep); + obj.Proxy.setEndpoint(ep); + obj.Endpoint = ep; + end + + function obj = set.Format(obj, newformat) + newformat = validatestring(newformat, ["JSON", "binary"]); + obj.Proxy.setFormat(newformat); + obj.Format = newformat; + end + + function obj = set.JsonBytesMapping(obj, jbm) + jbm = validatestring(jbm, ["hex", "hexId", "base64"]); + obj.Proxy.setJsonBytesMapping(jbm); + obj.JsonBytesMapping = jbm; + end + + function obj = set.UseJsonName(obj, ujn) + if ~((islogical(ujn) || isnumeric(ujn)) && isscalar(ujn)) + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:UseJsonNameNotScalarLogical", "UseJsonName must be a scalar logical.") end - obj.UseJsonName = usejsonname; - if timeout_millis < 0 % not specified, use default value - obj.Timeout = milliseconds(defaultmillis); - else - obj.Timeout = timeout; + ujn = logical(ujn); + obj.Proxy.setUseJsonName(ujn); + obj.UseJsonName = ujn; + end + + function obj = set.Timeout(obj, timeout) + if ~(isduration(timeout) && isscalar(timeout)) + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:TimeoutNotScalarDuration", "Timeout must be a scalar duration."); end - if isempty(headerkeys) % not specified, return empty dictionary - obj.HttpHeaders = dictionary(headerkeys, headervalues); - else - obj.HttpHeaders = httpheaders; + obj.Proxy.setTimeout(milliseconds(timeout)); + obj.Timeout = timeout; + end + + function obj = set.HttpHeaders(obj, httpheaders) + if ~isa(httpheaders, "dictionary") + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:HttpHeadersNotDictionary", "HttpHeaders input must be a dictionary."); end - if temporality == "" - obj.PreferredAggregationTemporality = defaulttemporality; - else - obj.PreferredAggregationTemporality = temporality; + headerkeys = keys(httpheaders); + headervalues = values(httpheaders); + if ~isstring(headervalues) + error("opentelemetry:exporters:otlp:OtlpHttpMetricExporter:HttpHeadersNonStringValues", "HttpHeaders dictionary values must be strings.") end + obj.Proxy.setHttpHeaders(headerkeys, headervalues); + obj.HttpHeaders = httpheaders; + end + + function obj = set.PreferredAggregationTemporality(obj, temporality) + temporality = validatestring(temporality, ["cumulative", "delta"]); + obj.Proxy.setTemporality(temporality); + obj.PreferredAggregationTemporality = temporality; end end end diff --git a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h index e372672..4d7afd0 100644 --- a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h +++ b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpGrpcMetricExporterProxy.h @@ -17,14 +17,26 @@ namespace libmexclass::opentelemetry::exporters { class OtlpGrpcMetricExporterProxy: public libmexclass::opentelemetry::sdk::MetricExporterProxy { public: OtlpGrpcMetricExporterProxy(otlp_exporter::OtlpGrpcMetricExporterOptions options) : CppOptions(options) { - REGISTER_METHOD(OtlpGrpcMetricExporterProxy, getDefaultOptionValues); + REGISTER_METHOD(OtlpGrpcMetricExporterProxy, setEndpoint); + REGISTER_METHOD(OtlpGrpcMetricExporterProxy, setUseCredentials); + REGISTER_METHOD(OtlpGrpcMetricExporterProxy, setCertificatePath); + REGISTER_METHOD(OtlpGrpcMetricExporterProxy, setCertificateString); + REGISTER_METHOD(OtlpGrpcMetricExporterProxy, setTimeout); + REGISTER_METHOD(OtlpGrpcMetricExporterProxy, setHttpHeaders); + REGISTER_METHOD(OtlpGrpcMetricExporterProxy, setTemporality); } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); std::unique_ptr getInstance() override; - void getDefaultOptionValues(libmexclass::proxy::method::Context& context); + void setEndpoint(libmexclass::proxy::method::Context& context); + void setUseCredentials(libmexclass::proxy::method::Context& context); + void setCertificatePath(libmexclass::proxy::method::Context& context); + void setCertificateString(libmexclass::proxy::method::Context& context); + void setTimeout(libmexclass::proxy::method::Context& context); + void setHttpHeaders(libmexclass::proxy::method::Context& context); + void setTemporality(libmexclass::proxy::method::Context& context); private: otlp_exporter::OtlpGrpcMetricExporterOptions CppOptions; diff --git a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h index 2dc929b..e5b920d 100644 --- a/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h +++ b/exporters/otlp/include/opentelemetry-matlab/exporters/otlp/OtlpHttpMetricExporterProxy.h @@ -17,14 +17,26 @@ namespace libmexclass::opentelemetry::exporters { class OtlpHttpMetricExporterProxy: public libmexclass::opentelemetry::sdk::MetricExporterProxy { public: OtlpHttpMetricExporterProxy(otlp_exporter::OtlpHttpMetricExporterOptions options) : CppOptions(options) { - REGISTER_METHOD(OtlpHttpMetricExporterProxy, getDefaultOptionValues); + REGISTER_METHOD(OtlpHttpMetricExporterProxy, setEndpoint); + REGISTER_METHOD(OtlpHttpMetricExporterProxy, setFormat); + REGISTER_METHOD(OtlpHttpMetricExporterProxy, setJsonBytesMapping); + REGISTER_METHOD(OtlpHttpMetricExporterProxy, setUseJsonName); + REGISTER_METHOD(OtlpHttpMetricExporterProxy, setTimeout); + REGISTER_METHOD(OtlpHttpMetricExporterProxy, setHttpHeaders); + REGISTER_METHOD(OtlpHttpMetricExporterProxy, setTemporality); } static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); std::unique_ptr getInstance() override; - void getDefaultOptionValues(libmexclass::proxy::method::Context& context); + void setEndpoint(libmexclass::proxy::method::Context& context); + void setFormat(libmexclass::proxy::method::Context& context); + void setJsonBytesMapping(libmexclass::proxy::method::Context& context); + void setUseJsonName(libmexclass::proxy::method::Context& context); + void setTimeout(libmexclass::proxy::method::Context& context); + void setHttpHeaders(libmexclass::proxy::method::Context& context); + void setTemporality(libmexclass::proxy::method::Context& context); private: otlp_exporter::OtlpHttpMetricExporterOptions CppOptions; diff --git a/exporters/otlp/src/OtlpGrpcMetricExporterProxy.cpp b/exporters/otlp/src/OtlpGrpcMetricExporterProxy.cpp index 0e0749a..6febee9 100644 --- a/exporters/otlp/src/OtlpGrpcMetricExporterProxy.cpp +++ b/exporters/otlp/src/OtlpGrpcMetricExporterProxy.cpp @@ -10,51 +10,7 @@ namespace otlp_exporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::exporters { libmexclass::proxy::MakeResult OtlpGrpcMetricExporterProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { - matlab::data::StringArray endpoint_mda = constructor_arguments[0]; - std::string endpoint = static_cast(endpoint_mda[0]); - matlab::data::TypedArray use_ssl_mda = constructor_arguments[1]; - bool use_ssl = use_ssl_mda[0]; - matlab::data::StringArray certpath_mda = constructor_arguments[2]; - std::string certpath = static_cast(certpath_mda[0]); - matlab::data::StringArray certstring_mda = constructor_arguments[3]; - std::string certstring = static_cast(certstring_mda[0]); - matlab::data::TypedArray timeout_mda = constructor_arguments[4]; - double timeout = timeout_mda[0]; - matlab::data::Array header_mda = constructor_arguments[5]; - size_t nheaders = header_mda.getNumberOfElements(); - matlab::data::StringArray headernames_mda = constructor_arguments[5]; - matlab::data::StringArray headervalues_mda = constructor_arguments[6]; - matlab::data::StringArray temporality_mda = constructor_arguments[7]; - std::string temporality = static_cast(temporality_mda[0]); - otlp_exporter::OtlpGrpcMetricExporterOptions options; - if (!endpoint.empty()) { - options.endpoint = endpoint; - } - // use_ssl - options.use_ssl_credentials = use_ssl; - if (!certpath.empty()) { - options.ssl_credentials_cacert_path = certpath; - } - if (!certstring.empty()) { - options.ssl_credentials_cacert_as_string = certstring; - } - // timeout - if (timeout >= 0) { - options.timeout = std::chrono::milliseconds(static_cast(timeout)); - } - // http headers - for (size_t i = 0; i < nheaders; ++i) { - options.metadata.insert(std::pair{static_cast(headernames_mda[i]), - static_cast(headervalues_mda[i])}); - } - // Preferred Aggregation Temporality - if (temporality.compare("Cumulative") == 0) { - options.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kCumulative; - } - else if (temporality.compare("Delta") == 0) { - options.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kDelta; - } return std::make_shared(options); } @@ -62,34 +18,66 @@ std::unique_ptr OtlpGrpcMetricExporterProxy::get return otlp_exporter::OtlpGrpcMetricExporterFactory::Create(CppOptions); } -void OtlpGrpcMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::method::Context& context) { - otlp_exporter::OtlpGrpcMetricExporterOptions options; - matlab::data::ArrayFactory factory; - auto endpoint_mda = factory.createScalar(options.endpoint); - auto certpath_mda = factory.createScalar(options.ssl_credentials_cacert_path); - auto certstring_mda = factory.createScalar(options.ssl_credentials_cacert_as_string); - auto timeout_millis = std::chrono::duration_cast(options.timeout); - auto timeout_mda = factory.createScalar(static_cast(timeout_millis.count())); - std::string aggregation_temporality; - // Preferred Aggregation Temporality - if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kCumulative){ - aggregation_temporality = "Cumulative"; +void OtlpGrpcMetricExporterProxy::setEndpoint(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray endpoint_mda = context.inputs[0]; + std::string endpoint = static_cast(endpoint_mda[0]); + + if (!endpoint.empty()) { + CppOptions.endpoint = endpoint; } - else if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kDelta){ - aggregation_temporality = "Delta"; +} + + +void OtlpGrpcMetricExporterProxy::setUseCredentials(libmexclass::proxy::method::Context& context) { + matlab::data::TypedArray use_credentials_mda = context.inputs[0]; + CppOptions.use_ssl_credentials = use_credentials_mda[0]; +} + +void OtlpGrpcMetricExporterProxy::setCertificatePath(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray certpath_mda = context.inputs[0]; + std::string certpath = static_cast(certpath_mda[0]); + + if (!certpath.empty()) { + CppOptions.ssl_credentials_cacert_path = certpath; + } +} + +void OtlpGrpcMetricExporterProxy::setCertificateString(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray certstr_mda = context.inputs[0]; + std::string certstr = static_cast(certstr_mda[0]); + + if (!certstr.empty()) { + CppOptions.ssl_credentials_cacert_as_string = certstr; + } +} + +void OtlpGrpcMetricExporterProxy::setTimeout(libmexclass::proxy::method::Context& context) { + matlab::data::TypedArray timeout_mda = context.inputs[0]; + double timeout = timeout_mda[0]; + + if (timeout >= 0) { + CppOptions.timeout = std::chrono::milliseconds(static_cast(timeout)); } - else if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kLowMemory){ - aggregation_temporality = "LowMemory"; +} + +void OtlpGrpcMetricExporterProxy::setHttpHeaders(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray headernames_mda = context.inputs[0]; + matlab::data::StringArray headervalues_mda = context.inputs[1]; + size_t nheaders = headernames_mda.getNumberOfElements(); + for (size_t i = 0; i < nheaders; ++i) { + CppOptions.metadata.insert(std::pair{static_cast(headernames_mda[i]), + static_cast(headervalues_mda[i])}); } - else { - aggregation_temporality = "Unspecified"; +} + +void OtlpGrpcMetricExporterProxy::setTemporality(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray temporality_mda = context.inputs[0]; + std::string temporality = static_cast(temporality_mda[0]); + + if (temporality.compare("cumulative") == 0) { + CppOptions.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kCumulative; + } else if (temporality.compare("delta") == 0) { + CppOptions.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kDelta; } - auto aggregation_temporality_mda = factory.createScalar(aggregation_temporality); - context.outputs[0] = endpoint_mda; - context.outputs[1] = certpath_mda; - context.outputs[2] = certstring_mda; - context.outputs[3] = timeout_mda; - context.outputs[4] = aggregation_temporality_mda; - } } // namespace libmexclass::opentelemetry diff --git a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp index e1636b5..a523dd2 100644 --- a/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp +++ b/exporters/otlp/src/OtlpHttpMetricExporterProxy.cpp @@ -10,111 +10,80 @@ namespace otlp_exporter = opentelemetry::exporter::otlp; namespace libmexclass::opentelemetry::exporters { libmexclass::proxy::MakeResult OtlpHttpMetricExporterProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { - matlab::data::StringArray endpoint_mda = constructor_arguments[0]; + otlp_exporter::OtlpHttpMetricExporterOptions options; + return std::make_shared(options); +} + +std::unique_ptr OtlpHttpMetricExporterProxy::getInstance() { + return otlp_exporter::OtlpHttpMetricExporterFactory::Create(CppOptions); +} + +void OtlpHttpMetricExporterProxy::setEndpoint(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray endpoint_mda = context.inputs[0]; std::string endpoint = static_cast(endpoint_mda[0]); - matlab::data::StringArray dataformat_mda = constructor_arguments[1]; - std::string dataformat = static_cast(dataformat_mda[0]); - matlab::data::StringArray json_bytes_mapping_mda = constructor_arguments[2]; - std::string json_bytes_mapping = static_cast(json_bytes_mapping_mda[0]); - matlab::data::TypedArray use_json_name_mda = constructor_arguments[3]; - bool use_json_name = use_json_name_mda[0]; - matlab::data::TypedArray timeout_mda = constructor_arguments[4]; - double timeout = timeout_mda[0]; - matlab::data::Array header_mda = constructor_arguments[5]; - size_t nheaders = header_mda.getNumberOfElements(); - matlab::data::StringArray headernames_mda = constructor_arguments[5]; - matlab::data::StringArray headervalues_mda = constructor_arguments[6]; - matlab::data::StringArray temporality_mda = constructor_arguments[7]; - std::string temporality = static_cast(temporality_mda[0]); - otlp_exporter::OtlpHttpMetricExporterOptions options; - if (!endpoint.empty()) { - options.url = endpoint; - } - // TODO: store the relationship between strings and enums in an associative container - // dataformat + CppOptions.url = endpoint; + } +} + +void OtlpHttpMetricExporterProxy::setFormat(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray dataformat_mda = context.inputs[0]; + std::string dataformat = static_cast(dataformat_mda[0]); + if (dataformat.compare("JSON") == 0) { - options.content_type = otlp_exporter::HttpRequestContentType::kJson; + CppOptions.content_type = otlp_exporter::HttpRequestContentType::kJson; } else if (dataformat.compare("binary") == 0) { - options.content_type = otlp_exporter::HttpRequestContentType::kBinary; + CppOptions.content_type = otlp_exporter::HttpRequestContentType::kBinary; } - // json_bytes_mapping +} + +void OtlpHttpMetricExporterProxy::setJsonBytesMapping(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray json_bytes_mapping_mda = context.inputs[0]; + std::string json_bytes_mapping = static_cast(json_bytes_mapping_mda[0]); + if (json_bytes_mapping.compare("hex") == 0) { - options.json_bytes_mapping = otlp_exporter::JsonBytesMappingKind::kHex; + CppOptions.json_bytes_mapping = otlp_exporter::JsonBytesMappingKind::kHex; } else if (json_bytes_mapping.compare("hexId") == 0) { - options.json_bytes_mapping = otlp_exporter::JsonBytesMappingKind::kHexId; + CppOptions.json_bytes_mapping = otlp_exporter::JsonBytesMappingKind::kHexId; } else if (json_bytes_mapping.compare("base64") == 0) { - options.json_bytes_mapping = otlp_exporter::JsonBytesMappingKind::kBase64; + CppOptions.json_bytes_mapping = otlp_exporter::JsonBytesMappingKind::kBase64; } - // use_json_name - options.use_json_name = use_json_name; - // timeout +} + +void OtlpHttpMetricExporterProxy::setUseJsonName(libmexclass::proxy::method::Context& context) { + matlab::data::TypedArray use_json_name_mda = context.inputs[0]; + CppOptions.use_json_name = use_json_name_mda[0]; +} + +void OtlpHttpMetricExporterProxy::setTimeout(libmexclass::proxy::method::Context& context) { + matlab::data::TypedArray timeout_mda = context.inputs[0]; + double timeout = timeout_mda[0]; + if (timeout >= 0) { - options.timeout = std::chrono::milliseconds(static_cast(timeout)); + CppOptions.timeout = std::chrono::milliseconds(static_cast(timeout)); } - // http headers +} + +void OtlpHttpMetricExporterProxy::setHttpHeaders(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray headernames_mda = context.inputs[0]; + matlab::data::StringArray headervalues_mda = context.inputs[1]; + size_t nheaders = headernames_mda.getNumberOfElements(); for (size_t i = 0; i < nheaders; ++i) { - options.http_headers.insert(std::pair{static_cast(headernames_mda[i]), + CppOptions.http_headers.insert(std::pair{static_cast(headernames_mda[i]), static_cast(headervalues_mda[i])}); } - // Preferred Aggregation Temporality - if (temporality.compare("Cumulative") == 0) { - options.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kCumulative; - } - else if (temporality.compare("Delta") == 0) { - options.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kDelta; - } - return std::make_shared(options); } -std::unique_ptr OtlpHttpMetricExporterProxy::getInstance() { - return otlp_exporter::OtlpHttpMetricExporterFactory::Create(CppOptions); -} +void OtlpHttpMetricExporterProxy::setTemporality(libmexclass::proxy::method::Context& context) { + matlab::data::StringArray temporality_mda = context.inputs[0]; + std::string temporality = static_cast(temporality_mda[0]); -void OtlpHttpMetricExporterProxy::getDefaultOptionValues(libmexclass::proxy::method::Context& context) { - otlp_exporter::OtlpHttpMetricExporterOptions options; - matlab::data::ArrayFactory factory; - auto endpoint_mda = factory.createScalar(options.url); - std::string dataformat, json_bytes_mapping, aggregation_temporality; - // dataformat - if (options.content_type == otlp_exporter::HttpRequestContentType::kJson) { - dataformat = "JSON"; - } else { - dataformat = "binary"; - } - // json_bytes_mapping - if (options.json_bytes_mapping == otlp_exporter::JsonBytesMappingKind::kHex) { - json_bytes_mapping = "hex"; - } else if (options.json_bytes_mapping == otlp_exporter::JsonBytesMappingKind::kHexId) { - json_bytes_mapping = "hexId"; - } else { // kBase64 - json_bytes_mapping = "base64"; + if (temporality.compare("cumulative") == 0) { + CppOptions.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kCumulative; + } else if (temporality.compare("delta") == 0) { + CppOptions.aggregation_temporality = otlp_exporter::PreferredAggregationTemporality::kDelta; } - // Preferred Aggregation Temporality - if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kCumulative){ - aggregation_temporality = "Cumulative"; - } - else if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kDelta){ - aggregation_temporality = "Delta"; - } - else if (options.aggregation_temporality == otlp_exporter::PreferredAggregationTemporality::kLowMemory){ - aggregation_temporality = "LowMemory"; - } - else { - aggregation_temporality = "Unspecified"; - } - - auto dataformat_mda = factory.createScalar(dataformat); - auto json_bytes_mapping_mda = factory.createScalar(json_bytes_mapping); - auto timeout_millis = std::chrono::duration_cast(options.timeout); - auto timeout_mda = factory.createScalar(static_cast(timeout_millis.count())); - auto aggregation_temporality_mda = factory.createScalar(aggregation_temporality); - context.outputs[0] = endpoint_mda; - context.outputs[1] = dataformat_mda; - context.outputs[2] = json_bytes_mapping_mda; - context.outputs[3] = timeout_mda; - context.outputs[4] = aggregation_temporality_mda; } } // namespace libmexclass::opentelemetry diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MetricExporter.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MetricExporter.m index c1fbd49..389d035 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MetricExporter.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MetricExporter.m @@ -3,7 +3,9 @@ % Copyright 2023 The MathWorks, Inc. - properties (Access=?opentelemetry.sdk.metrics.PeriodicExportingMetricReader) + properties (Access={?opentelemetry.sdk.metrics.PeriodicExportingMetricReader, ... + ?opentelemetry.exporters.otlp.OtlpHttpMetricExporter, ... + ?opentelemetry.exporters.otlp.OtlpGrpcMetricExporter}) Proxy % Proxy object to interface C++ code end diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m index d79c7bb..1b7aefc 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/PeriodicExportingMetricReader.m @@ -9,8 +9,11 @@ properties (SetAccess=immutable) MetricExporter % Metric exporter object responsible for exporting telemetry data to an OpenTelemetry Collector or a compatible backend. - Interval (1,1) duration - Timeout (1,1) duration + end + + properties + Interval (1,1) duration = minutes(1) + Timeout (1,1) duration = seconds(30) end methods %(Access=?opentelemetry.sdk.metrics.MeterProvider) @@ -24,46 +27,36 @@ optionnames (1,:) {mustBeTextScalar} optionvalues end + + obj.Proxy = libmexclass.proxy.Proxy("Name", "libmexclass.opentelemetry.sdk.PeriodicExportingMetricReaderProxy" , ... + "ConstructorArguments", {metricexporter.Proxy.ID}); + obj.MetricExporter = metricexporter; + validnames = ["Interval", "Timeout"]; - % set default values - intervalmillis = -1; - timeoutmillis = -1; for i = 1:length(optionnames) namei = validatestring(optionnames{i}, validnames); valuei = optionvalues{i}; - if strcmp(namei, "Interval") - if ~isduration(valuei) || ~isscalar(valuei) || valuei <= 0 || ... - round(valuei) ~= valuei - error("opentelemetry:sdk:metrics::PeriodicExportingMetricReader::InvalidInterval", ... - "Interval must be a positive duration integer."); - end - intervalmillis = milliseconds(valuei); - elseif strcmp(namei, "Timeout") - if ~isduration(valuei) || ~isscalar(valuei) || valuei <= 0 - error("opentelemetry:sdk:metrics:PeriodicExportingMetricReader:InvalidTimeout", ... - "Timeout must be a positive duration scalar."); - end - timeoutmillis = milliseconds(valuei); - end + obj.(namei) = valuei; end - - obj.MetricExporter = metricexporter; - obj.Proxy = libmexclass.proxy.Proxy("Name", "libmexclass.opentelemetry.sdk.PeriodicExportingMetricReaderProxy" , ... - "ConstructorArguments", {metricexporter.Proxy.ID, intervalmillis, timeoutmillis}); + end - [defaultinterval, defaulttimeout] = obj.Proxy.getDefaultOptionValues(); - if intervalmillis <= 0 - obj.Interval = milliseconds(defaultinterval); - else - obj.Interval = milliseconds(intervalmillis); + function obj = set.Interval(obj, interval) + if ~isduration(interval) || ~isscalar(interval) || interval <= 0 || ... + round(interval) ~= interval + error("opentelemetry:sdk:metrics:PeriodicExportingMetricReader:InvalidInterval", ... + "Interval must be a positive duration integer."); end - if timeoutmillis <= 0 - obj.Timeout = milliseconds(defaulttimeout); - else - obj.Timeout = milliseconds(timeoutmillis); - end - + obj.Proxy.setInterval(milliseconds(interval)); %#ok + obj.Interval = interval; + end + function obj = set.Timeout(obj, timeout) + if ~isduration(timeout) || ~isscalar(timeout) || timeout <= 0 + error("opentelemetry:sdk:metrics:PeriodicExportingMetricReader:InvalidTimeout", ... + "Timeout must be a positive duration scalar."); + end + obj.Proxy.setTimeout(milliseconds(timeout)); %#ok + obj.Timeout = timeout; end end end diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h index 21af4dd..bf66ffe 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h @@ -15,13 +15,15 @@ namespace metric_sdk = opentelemetry::sdk::metrics; namespace libmexclass::opentelemetry::sdk { class PeriodicExportingMetricReaderProxy : public libmexclass::proxy::Proxy { public: - PeriodicExportingMetricReaderProxy(std::shared_ptr exporter, double interval, double timeout); + PeriodicExportingMetricReaderProxy(std::shared_ptr exporter); static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); std::unique_ptr getInstance(); - void getDefaultOptionValues(libmexclass::proxy::method::Context& context); + void setInterval(libmexclass::proxy::method::Context& context); + + void setTimeout(libmexclass::proxy::method::Context& context); private: metric_sdk::PeriodicExportingMetricReaderOptions CppOptions; diff --git a/sdk/metrics/src/PeriodicExportingMetricReaderProxy.cpp b/sdk/metrics/src/PeriodicExportingMetricReaderProxy.cpp index 4f0f3e6..c4b05ed 100644 --- a/sdk/metrics/src/PeriodicExportingMetricReaderProxy.cpp +++ b/sdk/metrics/src/PeriodicExportingMetricReaderProxy.cpp @@ -10,18 +10,10 @@ namespace libmexclass::opentelemetry::sdk { -PeriodicExportingMetricReaderProxy::PeriodicExportingMetricReaderProxy(std::shared_ptr exporter, - double interval, double timeout) +PeriodicExportingMetricReaderProxy::PeriodicExportingMetricReaderProxy(std::shared_ptr exporter) : MetricExporter(exporter) { - - if (interval > 0) { - CppOptions.export_interval_millis = std::chrono::milliseconds(static_cast(interval)); - } - if (timeout > 0) { - CppOptions.export_timeout_millis = std::chrono::milliseconds(static_cast(timeout)); - } - - REGISTER_METHOD(PeriodicExportingMetricReaderProxy, getDefaultOptionValues); + REGISTER_METHOD(PeriodicExportingMetricReaderProxy, setInterval); + REGISTER_METHOD(PeriodicExportingMetricReaderProxy, setTimeout); } @@ -30,12 +22,8 @@ libmexclass::proxy::MakeResult PeriodicExportingMetricReaderProxy::make(const li libmexclass::proxy::ID exporterid = exporterid_mda[0]; std::shared_ptr exporter = std::static_pointer_cast( libmexclass::proxy::ProxyManager::getProxy(exporterid)); - matlab::data::TypedArray interval_mda = constructor_arguments[1]; - double interval = interval_mda[0]; - matlab::data::TypedArray timeout_mda = constructor_arguments[2]; - double timeout = timeout_mda[0]; - return std::make_shared(exporter, interval, timeout); + return std::make_shared(exporter); } @@ -45,15 +33,14 @@ std::unique_ptr PeriodicExportingMetricReaderProxy::ge } -void PeriodicExportingMetricReaderProxy::getDefaultOptionValues(libmexclass::proxy::method::Context& context){ - metric_sdk::PeriodicExportingMetricReaderOptions options; - matlab::data::ArrayFactory factory; - auto interval_mda = factory.createScalar(static_cast( - options.export_interval_millis.count())); - auto timeout_mda = factory.createScalar(static_cast( - options.export_timeout_millis.count())); - context.outputs[0] = interval_mda; - context.outputs[1] = timeout_mda; +void PeriodicExportingMetricReaderProxy::setInterval(libmexclass::proxy::method::Context& context) { + matlab::data::TypedArray interval_mda = context.inputs[0]; + CppOptions.export_interval_millis = std::chrono::milliseconds(static_cast(interval_mda[0])); +} + +void PeriodicExportingMetricReaderProxy::setTimeout(libmexclass::proxy::method::Context& context) { + matlab::data::TypedArray timeout_mda = context.inputs[0]; + CppOptions.export_timeout_millis = std::chrono::milliseconds(static_cast(timeout_mda[0])); } } // namespace libmexclass::opentelemetry diff --git a/test/tmetrics.m b/test/tmetrics.m index 9cecbf9..d869a9e 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -42,13 +42,13 @@ function testDefaultExporter(testCase) verifyEqual(testCase, string(class(exporter)), "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); verifyEqual(testCase, string(exporter.Endpoint), "http://localhost:4318/v1/metrics"); verifyEqual(testCase, exporter.Timeout, seconds(10)); - verifyEqual(testCase, string(exporter.PreferredAggregationTemporality), "Cumulative"); + verifyEqual(testCase, string(exporter.PreferredAggregationTemporality), "cumulative"); end function testExporterBasic(testCase) timeout = seconds(5); - temporality = "Delta"; + temporality = "delta"; exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter("Timeout", timeout, ... "PreferredAggregationTemporality", temporality); verifyEqual(testCase, exporter.Timeout, timeout); @@ -60,7 +60,7 @@ function testDefaultReader(testCase) reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(); verifyEqual(testCase, string(class(reader.MetricExporter)), ... "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); - verifyEqual(testCase, reader.Interval, seconds(60)); + verifyEqual(testCase, reader.Interval, minutes(1)); verifyEqual(testCase, reader.Timeout, seconds(30)); end @@ -81,9 +81,9 @@ function testAddMetricReader(testCase) metername = "foo"; countername = "bar"; exporter1 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... - "PreferredAggregationTemporality", "Delta"); + "PreferredAggregationTemporality", "delta"); exporter2 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... - "PreferredAggregationTemporality", "Delta"); + "PreferredAggregationTemporality", "delta"); reader1 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter1, ..., "Interval", seconds(2), "Timeout", seconds(1)); reader2 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter2, ..., From 58392caa736468df834fe112cf68f3b9f3283096 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 2 Nov 2023 13:13:55 -0400 Subject: [PATCH 31/40] Finishing add resource property to metrics --- .../+sdk/+metrics/MeterProvider.m | 3 - .../sdk/metrics/MeterProviderProxy.h | 2 + sdk/metrics/src/MeterProviderProxy.cpp | 6 +- test/myoutput.json | 0 test/tmetrics_sdk.m | 69 +++++++++++++++++++ 5 files changed, 75 insertions(+), 5 deletions(-) delete mode 100644 test/myoutput.json create mode 100644 test/tmetrics_sdk.m diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 934cbc1..6749285 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -10,9 +10,6 @@ properties (Access=public) MetricReader - end - - properties (Access=public) Resource end diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h index f0611f3..6d6ce13 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h @@ -22,6 +22,8 @@ #include "opentelemetry/sdk/metrics/meter_provider_factory.h" #include "opentelemetry/sdk/metrics/push_metric_exporter.h" #include "opentelemetry/sdk/resource/resource.h" +#include "opentelemetry/sdk/metrics/view/view_registry.h" +#include "opentelemetry/sdk/metrics/view/view_registry_factory.h" #include "opentelemetry-matlab/metrics/MeterProxy.h" diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index df8ef53..a94ee29 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -36,10 +36,12 @@ libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy auto reader = std::static_pointer_cast( libmexclass::proxy::ProxyManager::getProxy(readerid))->getInstance(); - auto p = metrics_sdk::MeterProviderFactory::Create(); + + auto view = metrics_sdk::ViewRegistryFactory::Create(); + auto p = metrics_sdk::MeterProviderFactory::Create(std::move(view), resource_custom); auto *p_sdk = static_cast(p.get()); p_sdk->AddMetricReader(std::move(reader)); - + auto p_out = nostd::shared_ptr(std::move(p)); out = std::make_shared(p_out); } diff --git a/test/myoutput.json b/test/myoutput.json deleted file mode 100644 index e69de29..0000000 diff --git a/test/tmetrics_sdk.m b/test/tmetrics_sdk.m new file mode 100644 index 0000000..528e7ec --- /dev/null +++ b/test/tmetrics_sdk.m @@ -0,0 +1,69 @@ +classdef tmetrics_sdk < matlab.unittest.TestCase + % tests for metrics SDK + + % Copyright 2023 The MathWorks, Inc. + + properties + OtelConfigFile + JsonFile + PidFile + OtelcolName + Otelcol + ListPid + ReadPidList + ExtractPid + Sigint + Sigterm + end + + methods (TestClassSetup) + function setupOnce(testCase) + commonSetupOnce(testCase); + end + end + + methods (TestMethodTeardown) + function teardown(testCase) + commonTeardown(testCase); + end + end + + methods (Test) + function testCustomResource(testCase) + % testCustomResource: check custom resources are included in + % emitted metrics + commonSetup(testCase) + + customkeys = ["foo" "bar"]; + customvalues = [1 5]; + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + mp = opentelemetry.sdk.metrics.MeterProvider(reader, ... + "Resource", dictionary(customkeys, customvalues)); + + m = getMeter(mp, "mymeter"); + c = createCounter(m, "mycounter"); + + % create testing value + val = 10; + + % add value and attributes + c.add(val); + + pause(2.5); + + % perform test comparisons + results = readJsonResults(testCase); + results = results{1}; + + resourcekeys = string({results.resourceMetrics.resource.attributes.key}); + for i = length(customkeys) + idx = find(resourcekeys == customkeys(i)); + verifyNotEmpty(testCase, idx); + verifyEqual(testCase, results.resourceMetrics.resource.attributes(idx).value.doubleValue, customvalues(i)); + end + end + + end +end \ No newline at end of file From b90544a37204b849ec20646a404275eac5a52805 Mon Sep 17 00:00:00 2001 From: duncanpo Date: Thu, 2 Nov 2023 13:22:19 -0400 Subject: [PATCH 32/40] add a test about issue #34 --- test/tmetrics.m | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/test/tmetrics.m b/test/tmetrics.m index d869a9e..04530a5 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -61,19 +61,23 @@ function testDefaultReader(testCase) verifyEqual(testCase, string(class(reader.MetricExporter)), ... "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); verifyEqual(testCase, reader.Interval, minutes(1)); + verifyEqual(testCase, reader.Interval.Format, 'm'); verifyEqual(testCase, reader.Timeout, seconds(30)); + verifyEqual(testCase, reader.Timeout.Format, 's'); end function testReaderBasic(testCase) exporter = opentelemetry.exporters.otlp.defaultMetricExporter; - interval = seconds(1); - timeout = seconds(0.5); + interval = hours(1); + timeout = minutes(30); reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... "Interval", interval, ... "Timeout", timeout); verifyEqual(testCase, reader.Interval, interval); + verifyEqual(testCase, reader.Interval.Format, 'h'); % should not be converted to other units verifyEqual(testCase, reader.Timeout, timeout); + verifyEqual(testCase, reader.Timeout.Format, 'm'); end From ee27f2ba94e88cad440167176321d0ea292bff5c Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 2 Nov 2023 13:36:38 -0400 Subject: [PATCH 33/40] Cleaning up code --- sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m | 2 +- .../opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h | 1 - sdk/metrics/src/MeterProviderProxy.cpp | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 6749285..98b816a 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -15,7 +15,7 @@ methods function obj = MeterProvider(reader, optionnames, optionvalues) - % SDK implementation of tracer provider + % SDK implementation of meter provider % MP = OPENTELEMETRY.SDK.METRICS.METERPROVIDER creates a meter % provider that uses a periodic exporting metric reader and default configurations. % diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h index 6d6ce13..8d6d144 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h @@ -35,7 +35,6 @@ namespace nostd = opentelemetry::nostd; namespace metrics_sdk = opentelemetry::sdk::metrics; namespace common = opentelemetry::common; namespace otlpexporter = opentelemetry::exporter::otlp; -namespace resource = opentelemetry::sdk::resource; namespace libmexclass::opentelemetry::sdk { diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index a94ee29..b70706d 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -12,7 +12,7 @@ libmexclass::proxy::MakeResult MeterProviderProxy::make(const libmexclass::proxy libmexclass::proxy::MakeResult out; if (constructor_arguments.getNumberOfElements() == 1) { - // if only one input, assume it is an API Tracer Provider to support type conversion + // if only one input, assume it is an API Meter Provider to support type conversion matlab::data::TypedArray mpid_mda = constructor_arguments[0]; libmexclass::proxy::ID mpid = mpid_mda[0]; auto mp = std::static_pointer_cast( From ac97746f17ce314719e2d08a52325966e8417787 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Thu, 2 Nov 2023 14:27:49 -0400 Subject: [PATCH 34/40] Change error message --- sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 98b816a..7c5ce87 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -68,7 +68,7 @@ if strcmp(namei, "Resource") if ~isa(valuei, "dictionary") error("opentelemetry:sdk:metrics:MeterProvider:InvalidResourceType", ... - "Attibutes input must be a dictionary."); + "Resource input must be a dictionary."); end resource = valuei; resourcekeys = keys(valuei); From 2bff102ef3f79fde98da0bfe45e721126632e244 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Fri, 3 Nov 2023 10:03:43 -0400 Subject: [PATCH 35/40] Correctly clearing meter providers --- test/tmetrics.m | 20 ++++++++++---------- test/tmetrics_sdk.m | 2 ++ 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/test/tmetrics.m b/test/tmetrics.m index d869a9e..607602a 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -101,7 +101,7 @@ function testAddMetricReader(testCase) % adding a single value ct.add(1); pause(2.5); - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); result_count = numel(results); verifyEqual(testCase,result_count, 2); @@ -136,7 +136,7 @@ function testCounterBasic(testCase) pause(2.5); % fetch result - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); results = results{end}; @@ -180,7 +180,7 @@ function testCounterDelta(testCase) % fetch results pause(2.5); - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); dp1 = results{1}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; dp2 = results{2}.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -219,7 +219,7 @@ function testCounterAddAttributes(testCase) pause(2.5); % fetch result - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); results = results{end}; @@ -263,7 +263,7 @@ function testCounterAddNegative(testCase) pause(2.5); % fetch results - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -303,7 +303,7 @@ function testUpDownCounterBasic(testCase) pause(5); % fetch result - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); results = results{end}; @@ -348,7 +348,7 @@ function testUpDownCounterAddAttributes(testCase) pause(5); % fetch result - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.sum.dataPoints; @@ -397,7 +397,7 @@ function testHistogramBasic(testCase) pause(10); % fetch results - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; @@ -454,7 +454,7 @@ function testHistogramRecordAttributes(testCase) pause(10); % fetch results - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); results = results{end}; dp = results.resourceMetrics.scopeMetrics.metrics.histogram.dataPoints; @@ -511,7 +511,7 @@ function testHistogramDelta(testCase) pause(2.5); % fetch results - verifyTrue(testCase, p.shutdown()); + clear p; results = readJsonResults(testCase); rsize = size(results); for i = 1:rsize(2) diff --git a/test/tmetrics_sdk.m b/test/tmetrics_sdk.m index 528e7ec..0f27729 100644 --- a/test/tmetrics_sdk.m +++ b/test/tmetrics_sdk.m @@ -53,6 +53,8 @@ function testCustomResource(testCase) pause(2.5); + clear mp; + % perform test comparisons results = readJsonResults(testCase); results = results{1}; From 4a12e67f4f39f84945adba85d8d6e6a0a8bd250e Mon Sep 17 00:00:00 2001 From: duncanpo Date: Fri, 3 Nov 2023 10:22:17 -0400 Subject: [PATCH 36/40] add a SynchronousInstrument base class --- api/metrics/+opentelemetry/+metrics/Counter.m | 41 ++++--------------- .../+opentelemetry/+metrics/Histogram.m | 36 ++++------------ .../+metrics/SynchronousInstrument.m | 24 +++++++++++ .../+opentelemetry/+metrics/UpDownCounter.m | 37 ++++------------- 4 files changed, 48 insertions(+), 90 deletions(-) create mode 100644 api/metrics/+opentelemetry/+metrics/SynchronousInstrument.m diff --git a/api/metrics/+opentelemetry/+metrics/Counter.m b/api/metrics/+opentelemetry/+metrics/Counter.m index f416f41..85a3448 100644 --- a/api/metrics/+opentelemetry/+metrics/Counter.m +++ b/api/metrics/+opentelemetry/+metrics/Counter.m @@ -1,59 +1,36 @@ -classdef Counter < handle - % Counter is a value that accumulates over time, - % you can think of this like an odometer on a car; it only ever goes up. +classdef Counter < opentelemetry.metrics.SynchronousInstrument + % Counter is a value that accumulates over time and can only increase + % but not decrease. % Copyright 2023 The MathWorks, Inc. - properties (SetAccess=immutable) - Name (1,1) string - Description (1,1) string - Unit (1,1) string - end - - properties (Access=private) - Proxy % Proxy object to interface C++ code - end - methods (Access={?opentelemetry.metrics.Meter}) - - function obj = Counter(proxy, ctname, ctdescription, ctunit) + function obj = Counter(proxy, name, description, unit) % Private constructor. Use createCounter method of Meter % to create Counters. - obj.Proxy = proxy; - obj.Name = ctname; - obj.Description = ctdescription; - obj.Unit = ctunit; + obj@opentelemetry.metrics.SynchronousInstrument(proxy, name, description, unit); end - end - + methods - function add(obj, value, varargin) % input value must be a numerical scalar if isnumeric(value) && isscalar(value) - if nargin == 2 obj.Proxy.add(value); - elseif isa(varargin{1}, "dictionary") attrkeys = keys(varargin{1}); attrvals = values(varargin{1},"cell"); if all(cellfun(@iscell, attrvals)) attrvals = [attrvals{:}]; end - obj.Proxy.add(value,attrkeys,attrvals); - + obj.Proxy.add(value, attrkeys, attrvals); else attrkeys = [varargin{1:2:length(varargin)}]'; attrvals = [varargin(2:2:length(varargin))]'; - obj.Proxy.add(value,attrkeys,attrvals); + obj.Proxy.add(value, attrkeys, attrvals); end end - end - end - - -end +end \ No newline at end of file diff --git a/api/metrics/+opentelemetry/+metrics/Histogram.m b/api/metrics/+opentelemetry/+metrics/Histogram.m index 8abc9ee..6cf0658 100644 --- a/api/metrics/+opentelemetry/+metrics/Histogram.m +++ b/api/metrics/+opentelemetry/+metrics/Histogram.m @@ -1,37 +1,21 @@ -classdef Histogram < handle - % Histogram is an instrument that adds or reduce values. +classdef Histogram < opentelemetry.metrics.SynchronousInstrument + % Histogram is an instrument that aggregates values into bins % Copyright 2023 The MathWorks, Inc. - properties (SetAccess=immutable) - Name (1,1) string - Description (1,1) string - Unit (1,1) string - end - - properties (Access=public) - Proxy % Proxy object to interface C++ code - end - methods (Access={?opentelemetry.metrics.Meter}) - - function obj = Histogram(proxy, hiname, hidescription, hiunit) + function obj = Histogram(proxy, name, description, unit) % Private constructor. Use createHistogram method of Meter % to create Histograms. - obj.Proxy = proxy; - obj.Name = hiname; - obj.Description = hidescription; - obj.Unit = hiunit; + obj@opentelemetry.metrics.SynchronousInstrument(proxy, name, description, unit); end - end - + methods - function record(obj, value, varargin) % input value must be a numerical scalar if isnumeric(value) && isscalar(value) - if nargin == 2 + if nargin == 2 obj.Proxy.record(value); elseif isa(varargin{1}, "dictionary") attrkeys = keys(varargin{1}); @@ -39,17 +23,13 @@ function record(obj, value, varargin) if all(cellfun(@iscell, attrvals)) attrvals = [attrvals{:}]; end - obj.Proxy.record(value,attrkeys,attrvals); + obj.Proxy.record(value, attrkeys, attrvals); else attrkeys = [varargin{1:2:length(varargin)}]'; attrvals = [varargin(2:2:length(varargin))]'; - obj.Proxy.record(value,attrkeys,attrvals); + obj.Proxy.record(value, attrkeys, attrvals); end end - end - end - - end diff --git a/api/metrics/+opentelemetry/+metrics/SynchronousInstrument.m b/api/metrics/+opentelemetry/+metrics/SynchronousInstrument.m new file mode 100644 index 0000000..8dbe33c --- /dev/null +++ b/api/metrics/+opentelemetry/+metrics/SynchronousInstrument.m @@ -0,0 +1,24 @@ +classdef SynchronousInstrument < handle + % Base class inherited by all synchronous instruments + + % Copyright 2023 The MathWorks, Inc. + + properties (SetAccess=immutable) + Name (1,1) string + Description (1,1) string + Unit (1,1) string + end + + properties (Access=protected) + Proxy % Proxy object to interface C++ code + end + + methods (Access=protected) + function obj = SynchronousInstrument(proxy, name, description, unit) + obj.Proxy = proxy; + obj.Name = name; + obj.Description = description; + obj.Unit = unit; + end + end +end \ No newline at end of file diff --git a/api/metrics/+opentelemetry/+metrics/UpDownCounter.m b/api/metrics/+opentelemetry/+metrics/UpDownCounter.m index b008dc5..cb04451 100644 --- a/api/metrics/+opentelemetry/+metrics/UpDownCounter.m +++ b/api/metrics/+opentelemetry/+metrics/UpDownCounter.m @@ -1,58 +1,35 @@ -classdef UpDownCounter < handle +classdef UpDownCounter < opentelemetry.metrics.SynchronousInstrument % UpDownCounter is an instrument that adds or reduce values. % Copyright 2023 The MathWorks, Inc. - properties (SetAccess=immutable) - Name (1,1) string - Description (1,1) string - Unit (1,1) string - end - - properties (Access=public) - Proxy % Proxy object to interface C++ code - end - methods (Access={?opentelemetry.metrics.Meter}) - - function obj = UpDownCounter(proxy, ctname, ctdescription, ctunit) + function obj = UpDownCounter(proxy, name, description, unit) % Private constructor. Use createUpDownCounter method of Meter % to create UpDownCounters. - obj.Proxy = proxy; - obj.Name = ctname; - obj.Description = ctdescription; - obj.Unit = ctunit; + obj@opentelemetry.metrics.SynchronousInstrument(proxy, name, description, unit); end - end - + methods - function add(obj, value, varargin) % input value must be a numerical scalar if isnumeric(value) && isscalar(value) - if nargin == 2 obj.Proxy.add(value); - elseif isa(varargin{1}, "dictionary") attrkeys = keys(varargin{1}); attrvals = values(varargin{1},"cell"); if all(cellfun(@iscell, attrvals)) attrvals = [attrvals{:}]; end - obj.Proxy.add(value,attrkeys,attrvals); - + obj.Proxy.add(value, attrkeys, attrvals); else attrkeys = [varargin{1:2:length(varargin)}]'; attrvals = [varargin(2:2:length(varargin))]'; - obj.Proxy.add(value,attrkeys,attrvals); + obj.Proxy.add(value, attrkeys, attrvals); end end - end - end - - -end +end \ No newline at end of file From adb6cd377230563a74e42d08719a3cad55efc162 Mon Sep 17 00:00:00 2001 From: duncanpo Date: Wed, 8 Nov 2023 11:00:57 -0500 Subject: [PATCH 37/40] enable Cleanup class to work for SDK objects --- CMakeLists.txt | 2 + .../+opentelemetry/+metrics/MeterProvider.m | 4 +- .../+opentelemetry/+trace/TracerProvider.m | 4 +- .../+opentelemetry/+sdk/+common/Cleanup.m | 95 +++++++++++++++++++ .../+opentelemetry/+sdk/+metrics/Cleanup.m | 63 ------------ .../+opentelemetry/+sdk/+trace/Cleanup.m | 63 ------------ test/performance/traceTest.m | 2 +- test/tmetrics_sdk.m | 80 ++++++++++++++++ 8 files changed, 182 insertions(+), 131 deletions(-) create mode 100644 sdk/common/+opentelemetry/+sdk/+common/Cleanup.m delete mode 100644 sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m delete mode 100644 sdk/trace/+opentelemetry/+sdk/+trace/Cleanup.m diff --git a/CMakeLists.txt b/CMakeLists.txt index ad8b889..ce462a5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -397,6 +397,7 @@ set(BAGGAGE_API_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/api/baggage/+opentele set(COMMON_API_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/api/common/+opentelemetry) set(TRACE_SDK_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/sdk/trace/+opentelemetry) set(METRICS_SDK_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/sdk/metrics/+opentelemetry) +set(COMMON_SDK_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/sdk/common/+opentelemetry) set(DEFAULT_EXPORTER_MATLAB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultSpanExporter.m ${CMAKE_CURRENT_SOURCE_DIR}/exporters/otlp/+opentelemetry/+exporters/+otlp/defaultMetricExporter.m) @@ -417,6 +418,7 @@ install(DIRECTORY ${BAGGAGE_API_MATLAB_SOURCES} DESTINATION .) install(DIRECTORY ${COMMON_API_MATLAB_SOURCES} DESTINATION .) install(DIRECTORY ${TRACE_SDK_MATLAB_SOURCES} DESTINATION .) install(DIRECTORY ${METRICS_SDK_MATLAB_SOURCES} DESTINATION .) +install(DIRECTORY ${COMMON_SDK_MATLAB_SOURCES} DESTINATION .) install(FILES ${DEFAULT_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) if(WITH_OTLP_HTTP) install(FILES ${OTLP_HTTP_EXPORTER_MATLAB_SOURCES} DESTINATION ${OTLP_EXPORTERS_DIR}) diff --git a/api/metrics/+opentelemetry/+metrics/MeterProvider.m b/api/metrics/+opentelemetry/+metrics/MeterProvider.m index bfb8a3b..8c06c11 100644 --- a/api/metrics/+opentelemetry/+metrics/MeterProvider.m +++ b/api/metrics/+opentelemetry/+metrics/MeterProvider.m @@ -4,7 +4,7 @@ % Copyright 2023 The MathWorks, Inc. - properties (Access={?opentelemetry.sdk.metrics.MeterProvider, ?opentelemetry.sdk.metrics.Cleanup}) + properties (Access={?opentelemetry.sdk.metrics.MeterProvider, ?opentelemetry.sdk.common.Cleanup}) Proxy % Proxy object to interface C++ code end @@ -60,7 +60,7 @@ function setMeterProvider(obj) end end - methods(Access=?opentelemetry.sdk.metrics.Cleanup) + methods(Access=?opentelemetry.sdk.common.Cleanup) function postShutdown(obj) % POSTSHUTDOWN Handle post-shutdown tasks obj.Proxy.postShutdown(); diff --git a/api/trace/+opentelemetry/+trace/TracerProvider.m b/api/trace/+opentelemetry/+trace/TracerProvider.m index 6cccc5a..a5cfbdc 100644 --- a/api/trace/+opentelemetry/+trace/TracerProvider.m +++ b/api/trace/+opentelemetry/+trace/TracerProvider.m @@ -5,7 +5,7 @@ % Copyright 2023 The MathWorks, Inc. properties (Access={?opentelemetry.sdk.trace.TracerProvider, ... - ?opentelemetry.sdk.trace.Cleanup}) + ?opentelemetry.sdk.common.Cleanup}) Proxy % Proxy object to interface C++ code end @@ -61,7 +61,7 @@ function setTracerProvider(obj) end end - methods(Access=?opentelemetry.sdk.trace.Cleanup) + methods(Access=?opentelemetry.sdk.common.Cleanup) function postShutdown(obj) % POSTSHUTDOWN Handle post-shutdown tasks obj.Proxy.postShutdown(); diff --git a/sdk/common/+opentelemetry/+sdk/+common/Cleanup.m b/sdk/common/+opentelemetry/+sdk/+common/Cleanup.m new file mode 100644 index 0000000..c7fe244 --- /dev/null +++ b/sdk/common/+opentelemetry/+sdk/+common/Cleanup.m @@ -0,0 +1,95 @@ +classdef Cleanup +% Clean up methods for TracerProvider and MeterProvider + +% Copyright 2023 The MathWorks, Inc. + + methods (Static) + function success = shutdown(p) + % SHUTDOWN Shutdown + % SUCCESS = SHUTDOWN(P) shuts down all processors/readers + % associated with P. P may be a tracer provider or a meter + % provider. Returns a logical that indicates whether + % shutdown was successful. + % + % See also FORCEFLUSH + + success = true; + % return false if input is not the right type + issdk = isa(p, "opentelemetry.sdk.trace.TracerProvider") || ... + isa(p, "opentelemetry.sdk.metrics.MeterProvider"); + if issdk + psdk = p; + elseif isa(p, "opentelemetry.trace.TracerProvider") + % convert to TracerProvider class in sdk + try + psdk = opentelemetry.sdk.trace.TracerProvider(p.Proxy); + catch + success = false; + end + elseif isa(p, "opentelemetry.metrics.MeterProvider") + % convert to MeterProvider class in sdk + try + psdk = opentelemetry.sdk.metrics.MeterProvider(p.Proxy); + catch + success = false; + end + else + success = false; + end + + if success % still not yet set to false, proceed to shutdown + success = psdk.shutdown; + if ~issdk + % API classes need extra work to swap to a no-op object + postShutdown(p); + end + end + end + + function success = forceFlush(p, timeout) + % FORCEFLUSH Force flush + % SUCCESS = FORCEFLUSH(P) immediately exports all spans + % or metrics that have not yet been exported. Returns a + % logical that indicates whether force flush was successful. + % + % SUCCESS = FORCEFLUSH(P, TIMEOUT) specifies a TIMEOUT + % duration. Force flush must be completed within this time, + % or else it will fail. + % + % See also SHUTDOWN + + success = true; + + % return false if input is not the right type + if isa(p, "opentelemetry.sdk.trace.TracerProvider") || ... + isa(p, "opentelemetry.sdk.metrics.MeterProvider") + psdk = p; + elseif isa(p, "opentelemetry.trace.TracerProvider") + % convert to TracerProvider class in sdk + try + psdk = opentelemetry.sdk.trace.TracerProvider(p.Proxy); + catch + success = false; + end + elseif isa(p, "opentelemetry.metrics.MeterProvider") + % convert to MeterProvider class in sdk + try + psdk = opentelemetry.sdk.metrics.MeterProvider(p.Proxy); + catch + success = false; + end + else + success = false; + end + + if success % still not yet set to false, proceed to force flush + if nargin < 2 || ~isa(timeout, "duration") + success = psdk.forceFlush; + else + success = psdk.forceFlush(timeout); + end + end + end + end + +end diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m deleted file mode 100644 index 0f31c4b..0000000 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/Cleanup.m +++ /dev/null @@ -1,63 +0,0 @@ -classdef Cleanup -% Clean up methods for MeterProvider in the API - -% Copyright 2023 The MathWorks, Inc. - - methods (Static) - function success = shutdown(mp) - % SHUTDOWN Shutdown - % SUCCESS = SHUTDOWN(MP) shuts down all metric readers associated with - % API meter provider MP and return a logical that indicates - % whether shutdown was successful. - % - % See also FORCEFLUSH - - % return false if input is not the right type - if isa(mp, "opentelemetry.metrics.MeterProvider") - % convert to MeterProvider class in sdk - try - mpsdk = opentelemetry.sdk.metrics.MeterProvider(mp.Proxy); - catch - success = false; - return - end - success = mpsdk.shutdown; - postShutdown(mp); - else - success = false; - end - end - - function success = forceFlush(mp, timeout) - % FORCEFLUSH Force flush - % SUCCESS = FORCEFLUSH(MP) immediately exports all metrics - % that have not yet been exported. Returns a logical that - % indicates whether force flush was successful. - % - % SUCCESS = FORCEFLUSH(MP, TIMEOUT) specifies a TIMEOUT - % duration. Force flush must be completed within this time, - % or else it will fail. - % - % See also SHUTDOWN - - % return false if input is not the right type - if isa(mp, "opentelemetry.metrics.MeterProvider") - % convert to MeterProvider class in sdk - try - mpsdk = opentelemetry.sdk.metrics.MeterProvider(mp.Proxy); - catch - success = false; - return - end - if nargin < 2 || ~isa(timeout, "duration") - success = mpsdk.forceFlush; - else - success = mpsdk.forceFlush(timeout); - end - else - success = false; - end - end - end - -end diff --git a/sdk/trace/+opentelemetry/+sdk/+trace/Cleanup.m b/sdk/trace/+opentelemetry/+sdk/+trace/Cleanup.m deleted file mode 100644 index d0f6e17..0000000 --- a/sdk/trace/+opentelemetry/+sdk/+trace/Cleanup.m +++ /dev/null @@ -1,63 +0,0 @@ -classdef Cleanup -% Clean up methods for TracerProvider in the API - -% Copyright 2023 The MathWorks, Inc. - - methods (Static) - function success = shutdown(tp) - % SHUTDOWN Shutdown - % SUCCESS = SHUTDOWN(TP) shuts down all span processors associated with - % API tracer provider TP and return a logical that indicates - % whether shutdown was successful. - % - % See also FORCEFLUSH - - % return false if input is not the right type - if isa(tp, "opentelemetry.trace.TracerProvider") - % convert to TracerProvider class in sdk - try - tpsdk = opentelemetry.sdk.trace.TracerProvider(tp.Proxy); - catch - success = false; - return - end - success = tpsdk.shutdown; - postShutdown(tp); - else - success = false; - end - end - - function success = forceFlush(tp, timeout) - % FORCEFLUSH Force flush - % SUCCESS = FORCEFLUSH(TP) immediately exports all spans - % that have not yet been exported. Returns a logical that - % indicates whether force flush was successful. - % - % SUCCESS = FORCEFLUSH(TP, TIMEOUT) specifies a TIMEOUT - % duration. Force flush must be completed within this time, - % or else it will fail. - % - % See also SHUTDOWN - - % return false if input is not the right type - if isa(tp, "opentelemetry.trace.TracerProvider") - % convert to TracerProvider class in sdk - try - tpsdk = opentelemetry.sdk.trace.TracerProvider(tp.Proxy); - catch - success = false; - return - end - if nargin < 2 || ~isa(timeout, "duration") - success = tpsdk.forceFlush; - else - success = tpsdk.forceFlush(timeout); - end - else - success = false; - end - end - end - -end diff --git a/test/performance/traceTest.m b/test/performance/traceTest.m index 91ed707..d9dbe41 100644 --- a/test/performance/traceTest.m +++ b/test/performance/traceTest.m @@ -37,7 +37,7 @@ function setup(testCase) function teardown(testCase) % Flush all spans that have not yet been exported tp = opentelemetry.trace.Provider.getTracerProvider(); - opentelemetry.sdk.trace.Cleanup.forceFlush(tp); + opentelemetry.sdk.common.Cleanup.forceFlush(tp); commonTeardown(testCase); end diff --git a/test/tmetrics_sdk.m b/test/tmetrics_sdk.m index 0f27729..d68e1b4 100644 --- a/test/tmetrics_sdk.m +++ b/test/tmetrics_sdk.m @@ -67,5 +67,85 @@ function testCustomResource(testCase) end end + function testShutdown(testCase) + % testShutdown: shutdown method should stop exporting + % of metrics + commonSetup(testCase) + + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + mp = opentelemetry.sdk.metrics.MeterProvider(reader); + + % shutdown the meter provider + verifyTrue(testCase, shutdown(mp)); + + % create an instrument and add some values + m = getMeter(mp, "foo"); + c = createCounter(m, "bar"); + c.add(5); + + % wait a little and then gather results, verify no metrics are + % generated + pause(2.5); + clear mp; + results = readJsonResults(testCase); + verifyEmpty(testCase, results); + end + + function testCleanupSdk(testCase) + % testCleanupSdk: shutdown an SDK meter provider through the Cleanup class + commonSetup(testCase) + + % Shut down an SDK meter provider instance + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + mp = opentelemetry.sdk.metrics.MeterProvider(reader); + + % shutdown the meter provider through the Cleanup class + verifyTrue(testCase, opentelemetry.sdk.common.Cleanup.shutdown(mp)); + + % create an instrument and add some values + m = getMeter(mp, "foo"); + c = createCounter(m, "bar"); + c.add(5); + + % wait a little and then gather results, verify no metrics are + % generated + pause(2.5); + clear mp; + results = readJsonResults(testCase); + verifyEmpty(testCase, results); + end + + function testCleanupApi(testCase) + % testCleanupApi: shutdown an API meter provider through the Cleanup class + commonSetup(testCase) + + % Shut down an API meter provider instance + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", seconds(2), "Timeout", seconds(1)); + mp = opentelemetry.sdk.metrics.MeterProvider(reader); + setMeterProvider(mp); + clear("mp"); + mp_api = opentelemetry.metrics.Provider.getMeterProvider(); + + % shutdown the API meter provider through the Cleanup class + verifyTrue(testCase, opentelemetry.sdk.common.Cleanup.shutdown(mp_api)); + + % create an instrument and add some values + m = getMeter(mp_api, "foo"); + c = createCounter(m, "bar"); + c.add(5); + + % wait a little and then gather results, verify no metrics are + % generated + pause(2.5); + clear("mp_api"); + results = readJsonResults(testCase); + verifyEmpty(testCase, results); + end end end \ No newline at end of file From 9f9fbc7ae48bd307db266d9b1cbc8467703de4e1 Mon Sep 17 00:00:00 2001 From: duncanpo Date: Thu, 9 Nov 2023 14:21:30 -0500 Subject: [PATCH 38/40] Complex number handling and more code sharing between metric instruments --- api/metrics/+opentelemetry/+metrics/Counter.m | 18 +- .../+opentelemetry/+metrics/Histogram.m | 18 +- .../+metrics/SynchronousInstrument.m | 22 +- .../+opentelemetry/+metrics/UpDownCounter.m | 18 +- .../metrics/CounterProxy.h | 4 +- .../metrics/HistogramProxy.h | 4 +- .../metrics/UpDownCounterProxy.h | 4 +- api/metrics/src/CounterProxy.cpp | 2 +- api/metrics/src/HistogramProxy.cpp | 2 +- api/metrics/src/UpDownCounterProxy.cpp | 2 +- test/tmetrics.m | 218 ++++++------------ test/tmetrics_sdk.m | 112 +++++++-- 12 files changed, 198 insertions(+), 226 deletions(-) diff --git a/api/metrics/+opentelemetry/+metrics/Counter.m b/api/metrics/+opentelemetry/+metrics/Counter.m index 85a3448..f189b90 100644 --- a/api/metrics/+opentelemetry/+metrics/Counter.m +++ b/api/metrics/+opentelemetry/+metrics/Counter.m @@ -14,23 +14,7 @@ methods function add(obj, value, varargin) - % input value must be a numerical scalar - if isnumeric(value) && isscalar(value) - if nargin == 2 - obj.Proxy.add(value); - elseif isa(varargin{1}, "dictionary") - attrkeys = keys(varargin{1}); - attrvals = values(varargin{1},"cell"); - if all(cellfun(@iscell, attrvals)) - attrvals = [attrvals{:}]; - end - obj.Proxy.add(value, attrkeys, attrvals); - else - attrkeys = [varargin{1:2:length(varargin)}]'; - attrvals = [varargin(2:2:length(varargin))]'; - obj.Proxy.add(value, attrkeys, attrvals); - end - end + obj.processValue(value, varargin{:}); end end end \ No newline at end of file diff --git a/api/metrics/+opentelemetry/+metrics/Histogram.m b/api/metrics/+opentelemetry/+metrics/Histogram.m index 6cf0658..439b636 100644 --- a/api/metrics/+opentelemetry/+metrics/Histogram.m +++ b/api/metrics/+opentelemetry/+metrics/Histogram.m @@ -13,23 +13,7 @@ methods function record(obj, value, varargin) - % input value must be a numerical scalar - if isnumeric(value) && isscalar(value) - if nargin == 2 - obj.Proxy.record(value); - elseif isa(varargin{1}, "dictionary") - attrkeys = keys(varargin{1}); - attrvals = values(varargin{1},"cell"); - if all(cellfun(@iscell, attrvals)) - attrvals = [attrvals{:}]; - end - obj.Proxy.record(value, attrkeys, attrvals); - else - attrkeys = [varargin{1:2:length(varargin)}]'; - attrvals = [varargin(2:2:length(varargin))]'; - obj.Proxy.record(value, attrkeys, attrvals); - end - end + obj.processValue(value, varargin{:}); end end end diff --git a/api/metrics/+opentelemetry/+metrics/SynchronousInstrument.m b/api/metrics/+opentelemetry/+metrics/SynchronousInstrument.m index 8dbe33c..a6d6b0b 100644 --- a/api/metrics/+opentelemetry/+metrics/SynchronousInstrument.m +++ b/api/metrics/+opentelemetry/+metrics/SynchronousInstrument.m @@ -9,7 +9,7 @@ Unit (1,1) string end - properties (Access=protected) + properties (Access=private) Proxy % Proxy object to interface C++ code end @@ -20,5 +20,25 @@ obj.Description = description; obj.Unit = unit; end + + function processValue(obj, value, varargin) + % input value must be a numerical real scalar + if isnumeric(value) && isscalar(value) && isreal(value) + if nargin == 2 + obj.Proxy.processValue(value); + elseif isa(varargin{1}, "dictionary") + attrkeys = keys(varargin{1}); + attrvals = values(varargin{1},"cell"); + if all(cellfun(@iscell, attrvals)) + attrvals = [attrvals{:}]; + end + obj.Proxy.processValue(value, attrkeys, attrvals); + else + attrkeys = [varargin{1:2:length(varargin)}]'; + attrvals = [varargin(2:2:length(varargin))]'; + obj.Proxy.processValue(value, attrkeys, attrvals); + end + end + end end end \ No newline at end of file diff --git a/api/metrics/+opentelemetry/+metrics/UpDownCounter.m b/api/metrics/+opentelemetry/+metrics/UpDownCounter.m index cb04451..073c3d7 100644 --- a/api/metrics/+opentelemetry/+metrics/UpDownCounter.m +++ b/api/metrics/+opentelemetry/+metrics/UpDownCounter.m @@ -13,23 +13,7 @@ methods function add(obj, value, varargin) - % input value must be a numerical scalar - if isnumeric(value) && isscalar(value) - if nargin == 2 - obj.Proxy.add(value); - elseif isa(varargin{1}, "dictionary") - attrkeys = keys(varargin{1}); - attrvals = values(varargin{1},"cell"); - if all(cellfun(@iscell, attrvals)) - attrvals = [attrvals{:}]; - end - obj.Proxy.add(value, attrkeys, attrvals); - else - attrkeys = [varargin{1:2:length(varargin)}]'; - attrvals = [varargin(2:2:length(varargin))]'; - obj.Proxy.add(value, attrkeys, attrvals); - end - end + obj.processValue(value, varargin{:}); end end end \ No newline at end of file diff --git a/api/metrics/include/opentelemetry-matlab/metrics/CounterProxy.h b/api/metrics/include/opentelemetry-matlab/metrics/CounterProxy.h index 6271d60..65b3827 100644 --- a/api/metrics/include/opentelemetry-matlab/metrics/CounterProxy.h +++ b/api/metrics/include/opentelemetry-matlab/metrics/CounterProxy.h @@ -18,10 +18,10 @@ namespace libmexclass::opentelemetry { class CounterProxy : public libmexclass::proxy::Proxy { public: CounterProxy(nostd::shared_ptr > ct) : CppCounter(ct) { - REGISTER_METHOD(CounterProxy, add); + REGISTER_METHOD(CounterProxy, processValue); } - void add(libmexclass::proxy::method::Context& context); + void processValue(libmexclass::proxy::method::Context& context); private: diff --git a/api/metrics/include/opentelemetry-matlab/metrics/HistogramProxy.h b/api/metrics/include/opentelemetry-matlab/metrics/HistogramProxy.h index 248c628..e055ede 100644 --- a/api/metrics/include/opentelemetry-matlab/metrics/HistogramProxy.h +++ b/api/metrics/include/opentelemetry-matlab/metrics/HistogramProxy.h @@ -21,10 +21,10 @@ namespace libmexclass::opentelemetry { class HistogramProxy : public libmexclass::proxy::Proxy { public: HistogramProxy(nostd::shared_ptr > hist) : CppHistogram(hist) { - REGISTER_METHOD(HistogramProxy, record); + REGISTER_METHOD(HistogramProxy, processValue); } - void record(libmexclass::proxy::method::Context& context); + void processValue(libmexclass::proxy::method::Context& context); private: diff --git a/api/metrics/include/opentelemetry-matlab/metrics/UpDownCounterProxy.h b/api/metrics/include/opentelemetry-matlab/metrics/UpDownCounterProxy.h index 6a41c75..132ba57 100644 --- a/api/metrics/include/opentelemetry-matlab/metrics/UpDownCounterProxy.h +++ b/api/metrics/include/opentelemetry-matlab/metrics/UpDownCounterProxy.h @@ -18,10 +18,10 @@ namespace libmexclass::opentelemetry { class UpDownCounterProxy : public libmexclass::proxy::Proxy { public: UpDownCounterProxy(nostd::shared_ptr > ct) : CppUpDownCounter(ct) { - REGISTER_METHOD(UpDownCounterProxy, add); + REGISTER_METHOD(UpDownCounterProxy, processValue); } - void add(libmexclass::proxy::method::Context& context); + void processValue(libmexclass::proxy::method::Context& context); private: diff --git a/api/metrics/src/CounterProxy.cpp b/api/metrics/src/CounterProxy.cpp index 77e498f..dab03f6 100644 --- a/api/metrics/src/CounterProxy.cpp +++ b/api/metrics/src/CounterProxy.cpp @@ -12,7 +12,7 @@ namespace libmexclass::opentelemetry { -void CounterProxy::add(libmexclass::proxy::method::Context& context){ +void CounterProxy::processValue(libmexclass::proxy::method::Context& context){ matlab::data::Array value_mda = context.inputs[0]; double value = static_cast(value_mda[0]); diff --git a/api/metrics/src/HistogramProxy.cpp b/api/metrics/src/HistogramProxy.cpp index 3d3ea5f..4c8ebfd 100644 --- a/api/metrics/src/HistogramProxy.cpp +++ b/api/metrics/src/HistogramProxy.cpp @@ -12,7 +12,7 @@ namespace libmexclass::opentelemetry { -void HistogramProxy::record(libmexclass::proxy::method::Context& context){ +void HistogramProxy::processValue(libmexclass::proxy::method::Context& context){ // Get value matlab::data::Array value_mda = context.inputs[0]; double value = static_cast(value_mda[0]); diff --git a/api/metrics/src/UpDownCounterProxy.cpp b/api/metrics/src/UpDownCounterProxy.cpp index f4d35ef..bcaa0c0 100644 --- a/api/metrics/src/UpDownCounterProxy.cpp +++ b/api/metrics/src/UpDownCounterProxy.cpp @@ -12,7 +12,7 @@ namespace libmexclass::opentelemetry { -void UpDownCounterProxy::add(libmexclass::proxy::method::Context& context){ +void UpDownCounterProxy::processValue(libmexclass::proxy::method::Context& context){ matlab::data::Array value_mda = context.inputs[0]; double value = static_cast(value_mda[0]); diff --git a/test/tmetrics.m b/test/tmetrics.m index a1bee5a..96adc99 100644 --- a/test/tmetrics.m +++ b/test/tmetrics.m @@ -15,11 +15,22 @@ ExtractPid Sigint Sigterm + ShortIntervalReader + DeltaAggregationReader end methods (TestClassSetup) function setupOnce(testCase) commonSetupOnce(testCase); + interval = seconds(2); + timeout = seconds(1); + testCase.ShortIntervalReader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(... + opentelemetry.exporters.otlp.OtlpHttpMetricExporter(), ... + "Interval", interval, "Timeout", timeout); + testCase.DeltaAggregationReader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(... + opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... + "PreferredAggregationTemporality", "Delta"), ... + "Interval", interval, "Timeout", timeout); end end @@ -36,91 +47,12 @@ function teardown(testCase) end methods (Test) - - function testDefaultExporter(testCase) - exporter = opentelemetry.exporters.otlp.defaultMetricExporter; - verifyEqual(testCase, string(class(exporter)), "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); - verifyEqual(testCase, string(exporter.Endpoint), "http://localhost:4318/v1/metrics"); - verifyEqual(testCase, exporter.Timeout, seconds(10)); - verifyEqual(testCase, string(exporter.PreferredAggregationTemporality), "cumulative"); - end - - - function testExporterBasic(testCase) - timeout = seconds(5); - temporality = "delta"; - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter("Timeout", timeout, ... - "PreferredAggregationTemporality", temporality); - verifyEqual(testCase, exporter.Timeout, timeout); - verifyEqual(testCase, string(exporter.PreferredAggregationTemporality), temporality); - end - - - function testDefaultReader(testCase) - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(); - verifyEqual(testCase, string(class(reader.MetricExporter)), ... - "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); - verifyEqual(testCase, reader.Interval, minutes(1)); - verifyEqual(testCase, reader.Interval.Format, 'm'); - verifyEqual(testCase, reader.Timeout, seconds(30)); - verifyEqual(testCase, reader.Timeout.Format, 's'); - end - - - function testReaderBasic(testCase) - exporter = opentelemetry.exporters.otlp.defaultMetricExporter; - interval = hours(1); - timeout = minutes(30); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", interval, ... - "Timeout", timeout); - verifyEqual(testCase, reader.Interval, interval); - verifyEqual(testCase, reader.Interval.Format, 'h'); % should not be converted to other units - verifyEqual(testCase, reader.Timeout, timeout); - verifyEqual(testCase, reader.Timeout.Format, 'm'); - end - - - function testAddMetricReader(testCase) - metername = "foo"; - countername = "bar"; - exporter1 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... - "PreferredAggregationTemporality", "delta"); - exporter2 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... - "PreferredAggregationTemporality", "delta"); - reader1 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter1, ..., - "Interval", seconds(2), "Timeout", seconds(1)); - reader2 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter2, ..., - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader1); - p.addMetricReader(reader2); - mt = p.getMeter(metername); - ct = mt.createCounter(countername); - - % verify if the provider has two metric readers attached - reader_count = numel(p.MetricReader); - verifyEqual(testCase,reader_count, 2); - - % verify if the json results has two exported instances after - % adding a single value - ct.add(1); - pause(2.5); - clear p; - results = readJsonResults(testCase); - result_count = numel(results); - verifyEqual(testCase,result_count, 2); - end - - function testCounterBasic(testCase) % test names and added value in Counter metername = "foo"; countername = "bar"; - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader); + p = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); mt = p.getMeter(metername); ct = mt.createCounter(countername); @@ -160,11 +92,7 @@ function testCounterDelta(testCase) metername = "foo"; countername = "bar"; - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... - "PreferredAggregationTemporality", "Delta"); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader); + p = opentelemetry.sdk.metrics.MeterProvider(testCase.DeltaAggregationReader); mt = p.getMeter(metername); ct = mt.createCounter(countername); @@ -201,10 +129,7 @@ function testCounterAddAttributes(testCase) metername = "foo"; countername = "bar"; - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader); + p = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); mt = p.getMeter(metername); ct = mt.createCounter(countername); @@ -249,21 +174,20 @@ function testCounterAddAttributes(testCase) end - function testCounterAddNegative(testCase) - % test if counter value remain 0 when added negative value - - metername = "foo"; - countername = "bar"; - - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader); - mt = p.getMeter(metername); - ct = mt.createCounter(countername); + function testCounterInvalidAdd(testCase) + % test if counter value remain 0 when added invalid values + p = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); + mt = p.getMeter("foo"); + ct = mt.createCounter("bar"); % add negative value to counter ct.add(-1); + % add add complex value + ct.add(2+3i); + % add nonscalar value + ct.add(magic(3)); + % add nonnumerics + ct.add("foobar"); pause(2.5); % fetch results @@ -284,10 +208,7 @@ function testUpDownCounterBasic(testCase) metername = "foo"; countername = "bar"; - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader); + p = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); mt = p.getMeter(metername); ct = mt.createUpDownCounter(countername); @@ -326,16 +247,9 @@ function testUpDownCounterBasic(testCase) function testUpDownCounterAddAttributes(testCase) % test names, added value and attributes in UpDownCounter - - metername = "foo"; - countername = "bar"; - - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader); - mt = p.getMeter(metername); - ct = mt.createUpDownCounter(countername); + p = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); + mt = p.getMeter("foo"); + ct = mt.createUpDownCounter("bar"); % create testing value and dictionary dict = dictionary("k1","v1","k2",5); @@ -371,6 +285,26 @@ function testUpDownCounterAddAttributes(testCase) end + function testUpDownCounterInvalidAdd(testCase) + % add invalid values to UpDownCounter + p = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); + mt = p.getMeter("foo"); + ct = mt.createUpDownCounter("bar"); + + % add add complex value + ct.add(2+3i); + % add nonscalar value + ct.add(magic(3)); + % add nonnumerics + ct.add("foobar"); + pause(2.5); + + % fetch results + clear p; + results = readJsonResults(testCase); + verifyEmpty(testCase, results); + end + function testHistogramBasic(testCase) % test recorded values in histogram @@ -378,10 +312,7 @@ function testHistogramBasic(testCase) metername = "foo"; histname = "bar"; - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader); + p = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); mt = p.getMeter(metername); hist = mt.createHistogram(histname); @@ -433,15 +364,9 @@ function testHistogramBasic(testCase) function testHistogramRecordAttributes(testCase) % test recorded values and attributes in histogram - metername = "foo"; - histname = "bar"; - - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader); - mt = p.getMeter(metername); - hist = mt.createHistogram(histname); + p = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); + mt = p.getMeter("foo"); + hist = mt.createHistogram("bar"); % create value and attributes for histogram dict = dictionary("k1","v1","k2","v2"); @@ -491,18 +416,30 @@ function testHistogramRecordAttributes(testCase) verifyEqual(testCase, str2double(counts{len}), sum(vals>bounds(len-1))); end + function testHistogramInvalidValue(testCase) + % add invalid values to Histogram + p = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); + mt = p.getMeter("foo"); + h = mt.createHistogram("bar"); + + % record add complex value + h.record(2+3i); + % record nonscalar value + h.record(magic(3)); + % record nonnumerics + h.record("foobar"); + pause(2.5); - function testHistogramDelta(testCase) - metername = "foo"; - histname = "bar"; + % fetch results + clear p; + results = readJsonResults(testCase); + verifyEmpty(testCase, results); + end - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... - "PreferredAggregationTemporality", "Delta"); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - p = opentelemetry.sdk.metrics.MeterProvider(reader); - mt = p.getMeter(metername); - hist = mt.createHistogram(histname); + function testHistogramDelta(testCase) + p = opentelemetry.sdk.metrics.MeterProvider(testCase.DeltaAggregationReader); + mt = p.getMeter("foo"); + hist = mt.createHistogram("bar"); % record value and attributes rawvals = [1 6]; @@ -544,10 +481,7 @@ function testHistogramDelta(testCase) function testGetSetMeterProvider(testCase) % testGetSetMeterProvider: setting and getting global instance of MeterProvider - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - mp = opentelemetry.sdk.metrics.MeterProvider(reader); + mp = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); setMeterProvider(mp); metername = "foo"; diff --git a/test/tmetrics_sdk.m b/test/tmetrics_sdk.m index d68e1b4..9a6a9fa 100644 --- a/test/tmetrics_sdk.m +++ b/test/tmetrics_sdk.m @@ -14,11 +14,21 @@ ExtractPid Sigint Sigterm + ShortIntervalReader end methods (TestClassSetup) function setupOnce(testCase) commonSetupOnce(testCase); + testCase.ShortIntervalReader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(... + opentelemetry.exporters.otlp.OtlpHttpMetricExporter(), ... + "Interval", seconds(2), "Timeout", seconds(1)); + end + end + + methods (TestMethodSetup) + function setup(testCase) + commonSetup(testCase); end end @@ -29,17 +39,86 @@ function teardown(testCase) end methods (Test) + function testDefaultExporter(testCase) + exporter = opentelemetry.exporters.otlp.defaultMetricExporter; + verifyEqual(testCase, string(class(exporter)), "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); + verifyEqual(testCase, string(exporter.Endpoint), "http://localhost:4318/v1/metrics"); + verifyEqual(testCase, exporter.Timeout, seconds(10)); + verifyEqual(testCase, string(exporter.PreferredAggregationTemporality), "cumulative"); + end + + + function testExporterBasic(testCase) + timeout = seconds(5); + temporality = "delta"; + exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter("Timeout", timeout, ... + "PreferredAggregationTemporality", temporality); + verifyEqual(testCase, exporter.Timeout, timeout); + verifyEqual(testCase, string(exporter.PreferredAggregationTemporality), temporality); + end + + + function testDefaultReader(testCase) + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(); + verifyEqual(testCase, string(class(reader.MetricExporter)), ... + "opentelemetry.exporters.otlp.OtlpHttpMetricExporter"); + verifyEqual(testCase, reader.Interval, minutes(1)); + verifyEqual(testCase, reader.Interval.Format, 'm'); + verifyEqual(testCase, reader.Timeout, seconds(30)); + verifyEqual(testCase, reader.Timeout.Format, 's'); + end + + + function testReaderBasic(testCase) + exporter = opentelemetry.exporters.otlp.defaultMetricExporter; + interval = hours(1); + timeout = minutes(30); + reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + "Interval", interval, ... + "Timeout", timeout); + verifyEqual(testCase, reader.Interval, interval); + verifyEqual(testCase, reader.Interval.Format, 'h'); % should not be converted to other units + verifyEqual(testCase, reader.Timeout, timeout); + verifyEqual(testCase, reader.Timeout.Format, 'm'); + end + + + function testAddMetricReader(testCase) + metername = "foo"; + countername = "bar"; + exporter1 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... + "PreferredAggregationTemporality", "delta"); + exporter2 = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(... + "PreferredAggregationTemporality", "delta"); + reader1 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter1, ..., + "Interval", seconds(2), "Timeout", seconds(1)); + reader2 = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter2, ..., + "Interval", seconds(2), "Timeout", seconds(1)); + p = opentelemetry.sdk.metrics.MeterProvider(reader1); + p.addMetricReader(reader2); + mt = p.getMeter(metername); + ct = mt.createCounter(countername); + + % verify if the provider has two metric readers attached + reader_count = numel(p.MetricReader); + verifyEqual(testCase,reader_count, 2); + + % verify if the json results has two exported instances after + % adding a single value + ct.add(1); + pause(2.5); + clear p; + results = readJsonResults(testCase); + result_count = numel(results); + verifyEqual(testCase,result_count, 2); + end + function testCustomResource(testCase) % testCustomResource: check custom resources are included in % emitted metrics - commonSetup(testCase) - customkeys = ["foo" "bar"]; customvalues = [1 5]; - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - mp = opentelemetry.sdk.metrics.MeterProvider(reader, ... + mp = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader, ... "Resource", dictionary(customkeys, customvalues)); m = getMeter(mp, "mymeter"); @@ -70,12 +149,7 @@ function testCustomResource(testCase) function testShutdown(testCase) % testShutdown: shutdown method should stop exporting % of metrics - commonSetup(testCase) - - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - mp = opentelemetry.sdk.metrics.MeterProvider(reader); + mp = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); % shutdown the meter provider verifyTrue(testCase, shutdown(mp)); @@ -95,13 +169,9 @@ function testShutdown(testCase) function testCleanupSdk(testCase) % testCleanupSdk: shutdown an SDK meter provider through the Cleanup class - commonSetup(testCase) % Shut down an SDK meter provider instance - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - mp = opentelemetry.sdk.metrics.MeterProvider(reader); + mp = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); % shutdown the meter provider through the Cleanup class verifyTrue(testCase, opentelemetry.sdk.common.Cleanup.shutdown(mp)); @@ -121,13 +191,9 @@ function testCleanupSdk(testCase) function testCleanupApi(testCase) % testCleanupApi: shutdown an API meter provider through the Cleanup class - commonSetup(testCase) - + % Shut down an API meter provider instance - exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); - reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... - "Interval", seconds(2), "Timeout", seconds(1)); - mp = opentelemetry.sdk.metrics.MeterProvider(reader); + mp = opentelemetry.sdk.metrics.MeterProvider(testCase.ShortIntervalReader); setMeterProvider(mp); clear("mp"); mp_api = opentelemetry.metrics.Provider.getMeterProvider(); From 94b9293dc07130e6805a95b92aae92344c58de36 Mon Sep 17 00:00:00 2001 From: duncanpo Date: Thu, 9 Nov 2023 16:57:08 -0500 Subject: [PATCH 39/40] back out a change to replace spaces in instrument names with underscore --- api/metrics/+opentelemetry/+metrics/Meter.m | 3 --- 1 file changed, 3 deletions(-) diff --git a/api/metrics/+opentelemetry/+metrics/Meter.m b/api/metrics/+opentelemetry/+metrics/Meter.m index b399bfd..45c2486 100644 --- a/api/metrics/+opentelemetry/+metrics/Meter.m +++ b/api/metrics/+opentelemetry/+metrics/Meter.m @@ -40,7 +40,6 @@ ctname = mustBeScalarString(ctname); % cpp-opentelemetry end does not allow string input with spaces, % replace any spaces with underscores as a temporary fix - ctname = strrep(ctname, ' ', '_'); ctdescription = mustBeScalarString(ctdescription); ctunit = mustBeScalarString(ctunit); id = obj.Proxy.createCounter(ctname, ctdescription, ctunit); @@ -62,7 +61,6 @@ ctname = mustBeScalarString(ctname); % cpp-opentelemetry end does not allow string input with spaces, % replace any spaces with underscores as a temporary fix - ctname = strrep(ctname, ' ', '_'); ctdescription = mustBeScalarString(ctdescription); ctunit = mustBeScalarString(ctunit); id = obj.Proxy.createUpDownCounter(ctname, ctdescription, ctunit); @@ -84,7 +82,6 @@ hiname = mustBeScalarString(hiname); % cpp-opentelemetry end does not allow string input with spaces, % replace any spaces with underscores as a temporary fix - hiname = strrep(hiname, ' ', '_'); hidescription = mustBeScalarString(hidescription); hiunit = mustBeScalarString(hiunit); id = obj.Proxy.createHistogram(hiname, hidescription, hiunit); From bfe1c5023ba5ea584377a8c737dfe6e4bc40dd35 Mon Sep 17 00:00:00 2001 From: Devin Narula Date: Fri, 10 Nov 2023 15:22:38 -0500 Subject: [PATCH 40/40] Adding View Class in metrics sdk and add view method to meter provider --- CMakeLists.txt | 1 + OtelMatlabProxyFactory.cpp | 2 + .../+sdk/+metrics/MeterProvider.m | 10 ++ .../+opentelemetry/+sdk/+metrics/View.m | 48 ++++++++ .../sdk/metrics/MeterProviderProxy.h | 3 + .../sdk/metrics/ViewProxy.h | 50 ++++++++ sdk/metrics/src/MeterProviderProxy.cpp | 12 ++ sdk/metrics/src/ViewProxy.cpp | 114 ++++++++++++++++++ test/tmetrics_sdk.m | 60 +++++++++ 9 files changed, 300 insertions(+) create mode 100644 sdk/metrics/+opentelemetry/+sdk/+metrics/View.m create mode 100644 sdk/metrics/include/opentelemetry-matlab/sdk/metrics/ViewProxy.h create mode 100644 sdk/metrics/src/ViewProxy.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index ad8b889..44525c9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -231,6 +231,7 @@ set(OPENTELEMETRY_PROXY_SOURCES ${TRACE_SDK_SOURCE_DIR}/BatchSpanProcessorProxy.cpp ${TRACE_SDK_SOURCE_DIR}/ParentBasedSamplerProxy.cpp ${METRICS_SDK_SOURCE_DIR}/MeterProviderProxy.cpp + ${METRICS_SDK_SOURCE_DIR}/ViewProxy.cpp ${METRICS_SDK_SOURCE_DIR}/PeriodicExportingMetricReaderProxy.cpp ${COMMON_SDK_SOURCE_DIR}/resource.cpp) if(WITH_OTLP_HTTP) diff --git a/OtelMatlabProxyFactory.cpp b/OtelMatlabProxyFactory.cpp index 8b04cf7..15b023b 100644 --- a/OtelMatlabProxyFactory.cpp +++ b/OtelMatlabProxyFactory.cpp @@ -23,6 +23,7 @@ #include "opentelemetry-matlab/sdk/trace/TraceIdRatioBasedSamplerProxy.h" #include "opentelemetry-matlab/sdk/trace/ParentBasedSamplerProxy.h" #include "opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h" +#include "opentelemetry-matlab/sdk/metrics/ViewProxy.h" #include "opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h" #ifdef WITH_OTLP_HTTP #include "opentelemetry-matlab/exporters/otlp/OtlpHttpSpanExporterProxy.h" @@ -61,6 +62,7 @@ OtelMatlabProxyFactory::make_proxy(const libmexclass::proxy::ClassName& class_na REGISTER_PROXY(libmexclass.opentelemetry.sdk.ParentBasedSamplerProxy, libmexclass::opentelemetry::sdk::ParentBasedSamplerProxy); REGISTER_PROXY(libmexclass.opentelemetry.sdk.MeterProviderProxy, libmexclass::opentelemetry::sdk::MeterProviderProxy); + REGISTER_PROXY(libmexclass.opentelemetry.sdk.ViewProxy, libmexclass::opentelemetry::sdk::ViewProxy); REGISTER_PROXY(libmexclass.opentelemetry.sdk.PeriodicExportingMetricReaderProxy, libmexclass::opentelemetry::sdk::PeriodicExportingMetricReaderProxy); #ifdef WITH_OTLP_HTTP diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m index 7c5ce87..268802d 100644 --- a/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/MeterProvider.m @@ -10,6 +10,7 @@ properties (Access=public) MetricReader + View Resource end @@ -98,6 +99,15 @@ function addMetricReader(obj, reader) obj.MetricReader = [obj.MetricReader, reader]; end + function addView(obj, view) + arguments + obj + view (1,1) {mustBeA(view, "opentelemetry.sdk.metrics.View")} + end + obj.Proxy.addView(view.Proxy.ID); + obj.View = [obj.View, view]; + end + function success = shutdown(obj) % SHUTDOWN Shutdown % SUCCESS = SHUTDOWN(MP) shuts down all metric readers associated with meter provider MP diff --git a/sdk/metrics/+opentelemetry/+sdk/+metrics/View.m b/sdk/metrics/+opentelemetry/+sdk/+metrics/View.m new file mode 100644 index 0000000..2ddf70b --- /dev/null +++ b/sdk/metrics/+opentelemetry/+sdk/+metrics/View.m @@ -0,0 +1,48 @@ +classdef View + +% Copyright 2023 The MathWorks, Inc. + + properties (GetAccess={?opentelemetry.sdk.metrics.MeterProvider}) + Proxy % Proxy object to interface C++ code + end + + properties (SetAccess=immutable) + Name + Description + Unit + InstrumentName + InstrumentType + MeterName + MeterVersion + MeterSchemaURL + AttributeKeys + Aggregation + HistogramBinEdges + end + + methods + function obj = View(name, description, unit, instrumentName, instrumentType, ... + meterName, meterVersion, meterSchemaURL, attributeKeys, ... + aggregation, histogramBinEdges, varargin) + + instrumentTypeCategory = int32(find(instrumentType==["kCounter", "kHistogram", "kUpDownCounter", "kObservableCounter", "kObservableGauge", "kObservableUpDownCounter"])-1); + + aggregationCategory = int32(find(instrumentType==["kDrop", "kHistogram", "kLastValue", "kSum", "kDefault"])-1); + + obj.Proxy = libmexclass.proxy.Proxy("Name", "libmexclass.opentelemetry.sdk.ViewProxy", ... + "ConstructorArguments", {name, description, unit, instrumentName, ... + instrumentTypeCategory, meterName, meterVersion, meterSchemaURL, ... + attributeKeys, aggregationCategory, histogramBinEdges, varargin}); + obj.Description = description; + obj.Unit = unit; + obj.InstrumentName = instrumentName; + obj.InstrumentType = instrumentType; + obj.MeterName = meterName; + obj.MeterVersion = meterVersion; + obj.MeterSchemaURL = meterSchemaURL; + obj.AttributeKeys = attributeKeys; + obj.Aggregation = aggregation; + obj.HistogramBinEdges = histogramBinEdges; + end + end +end \ No newline at end of file diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h index 8d6d144..a017c94 100644 --- a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h @@ -42,6 +42,7 @@ class MeterProviderProxy : public libmexclass::opentelemetry::MeterProviderProxy public: MeterProviderProxy(nostd::shared_ptr mp) : libmexclass::opentelemetry::MeterProviderProxy(mp) { REGISTER_METHOD(MeterProviderProxy, addMetricReader); + REGISTER_METHOD(MeterProviderProxy, addView); REGISTER_METHOD(MeterProviderProxy, shutdown); REGISTER_METHOD(MeterProviderProxy, forceFlush); } @@ -50,6 +51,8 @@ class MeterProviderProxy : public libmexclass::opentelemetry::MeterProviderProxy void addMetricReader(libmexclass::proxy::method::Context& context); + void addView(libmexclass::proxy::method::Context& context); + void shutdown(libmexclass::proxy::method::Context& context); void forceFlush(libmexclass::proxy::method::Context& context); diff --git a/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/ViewProxy.h b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/ViewProxy.h new file mode 100644 index 0000000..1bf18b6 --- /dev/null +++ b/sdk/metrics/include/opentelemetry-matlab/sdk/metrics/ViewProxy.h @@ -0,0 +1,50 @@ +// Copyright 2023 The MathWorks, Inc. + +#pragma once + +#include "libmexclass/proxy/Proxy.h" +#include "libmexclass/proxy/method/Context.h" + +#include "libmexclass/proxy/ProxyManager.h" + +#include "opentelemetry/sdk/metrics/view/view.h" +#include "opentelemetry/sdk/metrics/view/view_factory.h" +#include "opentelemetry/sdk/metrics/instruments.h" +#include "opentelemetry/sdk/metrics/aggregation/aggregation.h" +#include "opentelemetry/sdk/metrics/aggregation/aggregation_config.h" +#include "opentelemetry/sdk/metrics/view/attributes_processor.h" +#include "opentelemetry/sdk/metrics/view/instrument_selector.h" +#include "opentelemetry/sdk/metrics/view/instrument_selector_factory.h" +#include "opentelemetry/nostd/string_view.h" +#include "opentelemetry/sdk/metrics/view/meter_selector.h" +#include "opentelemetry/sdk/metrics/view/meter_selector_factory.h" + + +#include "opentelemetry-matlab/sdk/metrics/ViewProxy.h" + +namespace metrics_sdk = opentelemetry::sdk::metrics; +namespace nostd = opentelemetry::nostd; + +namespace libmexclass::opentelemetry::sdk { +class ViewProxy : public libmexclass::proxy::Proxy { +public: + ViewProxy(std::unique_ptr view, std::unique_ptr instrumentSelector, std::unique_ptr meterSelector); + + static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments); + + // void processView(libmexclass::proxy::method::Context& context); + + std::unique_ptr getView(libmexclass::proxy::method::Context& context); + + std::unique_ptr getInstrumentSelector(libmexclass::proxy::method::Context& context); + + std::unique_ptr getMeterSelector(libmexclass::proxy::method::Context& context); + +private: + std::unique_ptr View; + + std::unique_ptr InstrumentSelector; + + std::unique_ptr MeterSelector; +}; +} diff --git a/sdk/metrics/src/MeterProviderProxy.cpp b/sdk/metrics/src/MeterProviderProxy.cpp index b70706d..df2b535 100644 --- a/sdk/metrics/src/MeterProviderProxy.cpp +++ b/sdk/metrics/src/MeterProviderProxy.cpp @@ -2,6 +2,7 @@ #include "opentelemetry-matlab/sdk/metrics/MeterProviderProxy.h" #include "opentelemetry-matlab/sdk/metrics/PeriodicExportingMetricReaderProxy.h" +#include "opentelemetry-matlab/sdk/metrics/ViewProxy.h" #include "libmexclass/proxy/ProxyManager.h" @@ -58,6 +59,17 @@ void MeterProviderProxy::addMetricReader(libmexclass::proxy::method::Context& co return; } +void MeterProviderProxy::addView(libmexclass::proxy::method::Context& context) { + matlab::data::TypedArray viewid_mda = context.inputs[0]; + libmexclass::proxy::ID viewid = viewid_mda[0]; + + static_cast(*CppMeterProvider).AddView( + std::static_pointer_cast(libmexclass::proxy::ProxyManager::getProxy(viewid))->getInstrumentSelector(context), + std::static_pointer_cast(libmexclass::proxy::ProxyManager::getProxy(viewid))->getMeterSelector(context), + std::static_pointer_cast(libmexclass::proxy::ProxyManager::getProxy(viewid))->getView(context)); + return; +} + void MeterProviderProxy::shutdown(libmexclass::proxy::method::Context& context) { matlab::data::ArrayFactory factory; auto result_mda = factory.createScalar(static_cast(*CppMeterProvider).Shutdown()); diff --git a/sdk/metrics/src/ViewProxy.cpp b/sdk/metrics/src/ViewProxy.cpp new file mode 100644 index 0000000..0b80b17 --- /dev/null +++ b/sdk/metrics/src/ViewProxy.cpp @@ -0,0 +1,114 @@ +// Copyright 2023 The MathWorks, Inc. + +#include "opentelemetry-matlab/sdk/metrics/ViewProxy.h" + +#include "libmexclass/proxy/ProxyManager.h" + +#include + +namespace libmexclass::opentelemetry::sdk { +ViewProxy::ViewProxy(std::unique_ptr view, std::unique_ptr instrumentSelector, std::unique_ptr meterSelector){ + View = std::move(view); + InstrumentSelector = std::move(instrumentSelector); + MeterSelector = std::move(meterSelector); + REGISTER_METHOD(ViewProxy, getView); + REGISTER_METHOD(ViewProxy, getInstrumentSelector); + REGISTER_METHOD(ViewProxy, getMeterSelector); +} + +libmexclass::proxy::MakeResult ViewProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) { + libmexclass::proxy::MakeResult out; + + //Create View + matlab::data::StringArray name_mda = constructor_arguments[0]; + auto name = name_mda[0]; + + matlab::data::StringArray description_mda = constructor_arguments[1]; + auto description = description_mda[0]; + + matlab::data::StringArray unit_mda = constructor_arguments[2]; + auto unit = unit_mda[0]; + + matlab::data::TypedArray aggregation_type_mda = constructor_arguments[9]; + auto aggregation_type = static_cast(static_cast(aggregation_type_mda[0])); + + std::shared_ptr aggregation_config = std::shared_ptr(new metrics_sdk::HistogramAggregationConfig()); + if(aggregation_type == metrics_sdk::AggregationType::kHistogram){ + matlab::data::TypedArray histogramBinEdges_mda = constructor_arguments[10]; + std::vector histogramBinEdges; + for (auto h : histogramBinEdges_mda) { + histogramBinEdges.push_back(h); + } + aggregation_config->boundaries_ = histogramBinEdges; + } + + std::unique_ptr attributes_processor; + matlab::data::StringArray attributes_mda = constructor_arguments[8]; + if(attributes_mda.getNumberOfElements()==0){ + attributes_processor = std::unique_ptr(new metrics_sdk::DefaultAttributesProcessor()); + }else{ + std::unordered_map allowed_attribute_keys; + for (auto a : attributes_mda) { + allowed_attribute_keys[a] = true; + } + attributes_processor = std::unique_ptr(new metrics_sdk::FilteringAttributesProcessor(allowed_attribute_keys)); + } + + auto view = metrics_sdk::ViewFactory::Create(name, description, + unit, aggregation_type, std::move(aggregation_config), std::move(attributes_processor)); + + // Create Instrument Selector + matlab::data::TypedArray instrument_type_mda = constructor_arguments[4]; + auto instrument_type = static_cast(static_cast(instrument_type_mda[0])); + + matlab::data::StringArray instrument_name_mda = constructor_arguments[3]; + auto instrument_name = static_cast(instrument_name_mda[0]); + auto instrument_name_view = nostd::string_view(instrument_name); + + auto unit_view = nostd::string_view(static_cast(unit)); + + auto instrumentSelector = metrics_sdk::InstrumentSelectorFactory::Create(instrument_type, + instrument_name, unit_view); + + + // Create Meter Selector + matlab::data::StringArray meter_name_mda = constructor_arguments[5]; + auto meter_name = static_cast(meter_name_mda[0]); + auto meter_name_view = nostd::string_view(meter_name); + + matlab::data::StringArray meter_version_mda = constructor_arguments[6]; + auto meter_version = static_cast(meter_version_mda[0]); + auto meter_version_view = nostd::string_view(meter_version); + + matlab::data::StringArray meter_schema_mda = constructor_arguments[7]; + auto meter_schema = static_cast(meter_schema_mda[0]); + auto meter_schema_view = nostd::string_view(meter_schema); + + auto meterSelector = metrics_sdk::MeterSelectorFactory::Create(meter_name_view, + meter_version_view, meter_schema_view); + + + + // out = std::make_shared(nostd::shared_ptr( + // std::move(metrics_sdk::ViewFactory::Create(name, description, + // unit, aggregation_type, std::move(aggregation_config), std::move(attributes_processor))))); + + + // return out; + + return std::make_shared(std::move(view), std::move(instrumentSelector), std::move(meterSelector)); +} + +std::unique_ptr ViewProxy::getView(libmexclass::proxy::method::Context& context){ + return std::move(View); +} + +std::unique_ptr ViewProxy::getInstrumentSelector(libmexclass::proxy::method::Context& context){ + return std::move(InstrumentSelector); +} + +std::unique_ptr ViewProxy::getMeterSelector(libmexclass::proxy::method::Context& context){ + return std::move(MeterSelector); +} + +} diff --git a/test/tmetrics_sdk.m b/test/tmetrics_sdk.m index 0f27729..3fb0e6b 100644 --- a/test/tmetrics_sdk.m +++ b/test/tmetrics_sdk.m @@ -67,5 +67,65 @@ function testCustomResource(testCase) end end + % function testViewCounter(testCase) + % % testCustomResource: check custom resources are included in + % % emitted metrics + % commonSetup(testCase) + % + % exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + % reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + % "Interval", seconds(2), "Timeout", seconds(1)); + % mp = opentelemetry.sdk.metrics.MeterProvider(reader); + % + % m = getMeter(mp, "mymeter"); + % c = createCounter(m, "mycounter"); + % + % % create testing value + % val = 10; + % + % % add value and attributes + % c.add(val); + % + % pause(2.5); + % + % view = opentelemetry.sdk.metrics.View("View", "my View", "Unit", "Instrument", "kCounter", "mymeter", "", "", ["One" "Two" "Three"], "kDrop", [0 100 200 300 400 500]); + % + % addView(mp, view); + % + % clear mp; + % + % % % TODO: add test comparisons + % end + + % function testViewHistogram(testCase) + % % testCustomResource: check custom resources are included in + % % emitted metrics + % commonSetup(testCase) + % + % exporter = opentelemetry.exporters.otlp.OtlpHttpMetricExporter(); + % reader = opentelemetry.sdk.metrics.PeriodicExportingMetricReader(exporter, ... + % "Interval", seconds(2), "Timeout", seconds(1)); + % mp = opentelemetry.sdk.metrics.MeterProvider(reader); + % m = mp.getMeter("mymeter"); + % hist = m.createHistogram("histogram"); + % + % % create value for histogram + % val = 1; + % + % % record value + % hist.record(val); + % + % % wait for collector response + % pause(2.5); + % + % view = opentelemetry.sdk.metrics.View("View", "my View", "Unit", "Instrument", "kHistogram", "mymeter", "", "", ["One" "Two" "Three"], "kHistogram", [0 100 200 300 400 500]); + % + % addView(mp, view); + % + % clear mp; + % + % % % TODO: add test comparisons + % end + end end \ No newline at end of file