Add a static make method to all proxy classes, in response to change in libmexclass

Author: duncanpo

CMakeLists.txt

@@ -79,6 +79,7 @@ set(OPENTELEMETRY_PROXY_SOURCES
     ${CONTEXT_API_SOURCE_DIR}/ContextProxy.cpp
     ${BAGGAGE_API_SOURCE_DIR}/BaggageProxy.cpp
     ${TRACE_SDK_SOURCE_DIR}/TracerProviderProxy.cpp
+    ${TRACE_SDK_SOURCE_DIR}/SimpleSpanProcessorProxy.cpp
     ${TRACE_SDK_SOURCE_DIR}/BatchSpanProcessorProxy.cpp
     ${TRACE_SDK_SOURCE_DIR}/ParentBasedSamplerProxy.cpp
     ${OTLP_EXPORTER_SOURCE_DIR}/OtlpHttpSpanExporterProxy.cpp

OtelMatlabProxyFactory.cpp

@@ -25,12 +25,12 @@
 #include "opentelemetry-matlab/exporters/otlp/OtlpHttpSpanExporterProxy.h"
 #include "opentelemetry-matlab/exporters/otlp/OtlpGrpcSpanExporterProxy.h"
 
-std::shared_ptr<libmexclass::proxy::Proxy>
+libmexclass::proxy::MakeResult
 OtelMatlabProxyFactory::make_proxy(const libmexclass::proxy::ClassName& class_name,
                                const libmexclass::proxy::FunctionArguments& constructor_arguments) {
 
     REGISTER_PROXY(libmexclass.opentelemetry.TracerProviderProxy, libmexclass::opentelemetry::TracerProviderProxy);
-    REGISTER_PROXY(libmexclass.opentelemetry.TracerProxy, libmexclass::opentelemetry::TracerProxy);
+    //REGISTER_PROXY(libmexclass.opentelemetry.TracerProxy, libmexclass::opentelemetry::TracerProxy);
     REGISTER_PROXY(libmexclass.opentelemetry.SpanProxy, libmexclass::opentelemetry::SpanProxy);
     //REGISTER_PROXY(libmexclass.opentelemetry.ScopeProxy, libmexclass::opentelemetry::ScopeProxy);
     REGISTER_PROXY(libmexclass.opentelemetry.SpanContextProxy, libmexclass::opentelemetry::SpanContextProxy);

OtelMatlabProxyFactory.h

@@ -1,13 +1,13 @@
-// Copyright 2023 The MathWorks, Inc.
-
-#pragma once
-
-#include "libmexclass/proxy/Factory.h"
-
-class OtelMatlabProxyFactory : public libmexclass::proxy::Factory {
-  public:
-    OtelMatlabProxyFactory() {}
-    virtual std::shared_ptr<libmexclass::proxy::Proxy>
-    make_proxy(const libmexclass::proxy::ClassName& class_name,
-               const libmexclass::proxy::FunctionArguments& constructor_arguments);
-};
+// Copyright 2023 The MathWorks, Inc.
+
+#pragma once
+
+#include "libmexclass/proxy/Factory.h"
+
+class OtelMatlabProxyFactory : public libmexclass::proxy::Factory {
+  public:
+    OtelMatlabProxyFactory() {}
+    virtual libmexclass::proxy::MakeResult
+    make_proxy(const libmexclass::proxy::ClassName& class_name,
+               const libmexclass::proxy::FunctionArguments& constructor_arguments);
+};

api/baggage/include/opentelemetry-matlab/baggage/BaggagePropagatorProxy.h

@@ -15,9 +15,11 @@ namespace context_propagation = opentelemetry::context::propagation;
 namespace libmexclass::opentelemetry {
 class BaggagePropagatorProxy : public TextMapPropagatorProxy {
   public:
-    BaggagePropagatorProxy(const libmexclass::proxy::FunctionArguments& constructor_arguments)
-    {
-        CppPropagator = nostd::shared_ptr<context_propagation::TextMapPropagator>(new baggage_propagation::BaggagePropagator());
+    BaggagePropagatorProxy() : TextMapPropagatorProxy(nostd::shared_ptr<context_propagation::TextMapPropagator>(
+			    new baggage_propagation::BaggagePropagator())) {}
+
+    static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        return std::make_shared<BaggagePropagatorProxy>();
     }
 
     // getUniquePtrCopy is used by CompositePropagator, which needs a unique_ptr instance

api/baggage/include/opentelemetry-matlab/baggage/BaggageProxy.h

@@ -12,7 +12,14 @@ namespace nostd = opentelemetry::nostd;
 namespace libmexclass::opentelemetry {
 class BaggageProxy : public libmexclass::proxy::Proxy {
   public:
-    BaggageProxy(const libmexclass::proxy::FunctionArguments& constructor_arguments); 
+    BaggageProxy(nostd::shared_ptr<baggage_api::Baggage> bag) : CppBaggage(bag) {
+        REGISTER_METHOD(BaggageProxy, getAllEntries);
+        REGISTER_METHOD(BaggageProxy, setEntries);
+        REGISTER_METHOD(BaggageProxy, deleteEntries);
+        REGISTER_METHOD(BaggageProxy, insertBaggage);
+    }
+
+    static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
 
     void getAllEntries(libmexclass::proxy::method::Context& context);
     void setEntries(libmexclass::proxy::method::Context& context);

api/baggage/src/BaggageProxy.cpp

@@ -12,16 +12,16 @@
 
 namespace libmexclass::opentelemetry {
 
-BaggageProxy::BaggageProxy(const libmexclass::proxy::FunctionArguments& constructor_arguments) 
-{
+libmexclass::proxy::MakeResult BaggageProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
     size_t nin = constructor_arguments.getNumberOfElements();
+    nostd::shared_ptr<baggage_api::Baggage> baggage;
     if (nin == 1) {
         matlab::data::TypedArray<uint64_t> contextid_mda = constructor_arguments[0];
         libmexclass::proxy::ID contextid = contextid_mda[0];
 
 	context_api::Context ctxt = std::static_pointer_cast<ContextProxy>(
 		libmexclass::proxy::ProxyManager::getProxy(contextid))->getInstance();
-	CppBaggage = baggage_api::GetBaggage(ctxt);
+	baggage = baggage_api::GetBaggage(ctxt);
     } else {  // 2 inputs
         matlab::data::StringArray keys_mda = constructor_arguments[0];
         matlab::data::StringArray values_mda = constructor_arguments[1];
@@ -34,13 +34,9 @@ BaggageProxy::BaggageProxy(const libmexclass::proxy::FunctionArguments& construc
 			static_cast<std::string>(values_mda[i])));
 	}
 
-	CppBaggage = nostd::shared_ptr<baggage_api::Baggage>(new baggage_api::Baggage(attrs));
+	baggage = nostd::shared_ptr<baggage_api::Baggage>(new baggage_api::Baggage(attrs));
     }
-
-    REGISTER_METHOD(BaggageProxy, getAllEntries);
-    REGISTER_METHOD(BaggageProxy, setEntries);
-    REGISTER_METHOD(BaggageProxy, deleteEntries);
-    REGISTER_METHOD(BaggageProxy, insertBaggage);
+    return std::make_shared<BaggageProxy>(baggage);
 }
 
 void BaggageProxy::getAllEntries(libmexclass::proxy::method::Context& context) {

api/context/include/opentelemetry-matlab/context/ContextProxy.h

@@ -16,16 +16,15 @@ namespace context_api = opentelemetry::context;
 namespace libmexclass::opentelemetry {
 class ContextProxy : public libmexclass::proxy::Proxy {
   public:
-    // zero input supports the code path for empty context creation
-    // one input supports the code path for getCurrentContext
-    ContextProxy(const libmexclass::proxy::FunctionArguments& constructor_arguments) 
-	    : CppContext(constructor_arguments.isEmpty()? context_api::Context() : context_api::RuntimeContext::GetCurrent())
-    {
-        registerMethods();
+    ContextProxy(context_api::Context ctxt) : CppContext{ctxt} {
+        REGISTER_METHOD(ContextProxy, setCurrentContext);
     }
 
-    ContextProxy(context_api::Context ctxt) : CppContext{ctxt} {
-        registerMethods();
+    static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        // zero input supports the code path for empty context creation
+        // one input supports the code path for getCurrentContext
+        return std::make_shared<ContextProxy>(constructor_arguments.isEmpty()? 
+			context_api::Context() : context_api::RuntimeContext::GetCurrent());
     }
 
     context_api::Context getInstance() {
@@ -35,9 +34,6 @@ class ContextProxy : public libmexclass::proxy::Proxy {
     void setCurrentContext(libmexclass::proxy::method::Context& context);
 
   private:
-    void registerMethods() {
-        REGISTER_METHOD(ContextProxy, setCurrentContext);
-    }
 
     context_api::Context CppContext;
 };

api/context/include/opentelemetry-matlab/context/TokenProxy.h

@@ -15,7 +15,11 @@ namespace nostd = opentelemetry::nostd;
 namespace libmexclass::opentelemetry {
 class TokenProxy : public libmexclass::proxy::Proxy {
   public:
-    TokenProxy(const libmexclass::proxy::FunctionArguments& constructor_arguments) {}
+    TokenProxy() {}
+
+    static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        return std::make_shared<TokenProxy>();
+    }
 
     void setInstance(nostd::unique_ptr<context_api::Token>& instance) {
         CppToken.swap(instance);

api/context/include/opentelemetry-matlab/context/propagation/CompositePropagatorProxy.h

@@ -10,6 +10,8 @@
 namespace libmexclass::opentelemetry {
 class CompositePropagatorProxy : public TextMapPropagatorProxy {
   public:
-    CompositePropagatorProxy(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+    CompositePropagatorProxy(nostd::shared_ptr<context_propagation::TextMapPropagator> prop) : TextMapPropagatorProxy(prop) {}
+
+    static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
 };
 } // namespace libmexclass::opentelemetry

api/context/include/opentelemetry-matlab/context/propagation/TextMapCarrierProxy.h

@@ -10,23 +10,19 @@
 namespace libmexclass::opentelemetry {
 class TextMapCarrierProxy : public libmexclass::proxy::Proxy {
   public:
-    TextMapCarrierProxy(const libmexclass::proxy::FunctionArguments& constructor_arguments);
-
     TextMapCarrierProxy(const HttpTextMapCarrier& carrier) : CppCarrier(carrier) {
-        registerMethods();
+        REGISTER_METHOD(TextMapCarrierProxy, getHeaders);
     }
 
+    static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
     HttpTextMapCarrier getInstance() {
         return CppCarrier;
     }
 
     void getHeaders(libmexclass::proxy::method::Context& context);
 
   private:
-    void registerMethods() {
-        REGISTER_METHOD(TextMapCarrierProxy, getHeaders);
-    }
-
     HttpTextMapCarrier CppCarrier;
 };
 } // namespace libmexclass::opentelemetry