add shutdown and forceflush to sdk TracerProvider

Author: duncanpo

sdk/trace/+opentelemetry/+sdk/+trace/TracerProvider.m

@@ -6,6 +6,7 @@
 
     properties (Access=private)
         Proxy  % Proxy object to interface C++ code
+        isShutdown (1,1) logical = false
     end
 
     properties (SetAccess=private)
@@ -101,8 +102,10 @@ function addSpanProcessor(obj, processor)
                 obj
                 processor (1,1) {mustBeA(processor, "opentelemetry.sdk.trace.SpanProcessor")}
             end
-            obj.Proxy.addSpanProcessor(processor.Proxy.ID);
-            obj.SpanProcessor(end+1) = processor;  % append
+            if ~obj.isShutdown
+                obj.Proxy.addSpanProcessor(processor.Proxy.ID);
+                obj.SpanProcessor(end+1) = processor;  % append
+            end
         end
 
         function tracer = getTracer(obj, trname, trversion, trschema)
@@ -125,13 +128,14 @@ function addSpanProcessor(obj, processor)
             % name, version, schema accepts any types that can convert to a
             % string
             import opentelemetry.utils.mustBeScalarString
-            trname = mustBeScalarString(trname);          
+            trname = mustBeScalarString(trname);
             trversion = mustBeScalarString(trversion);
             trschema = mustBeScalarString(trschema);
             id = obj.Proxy.getTracer(trname, trversion, trschema);
-    	    tracerproxy = libmexclass.proxy.Proxy("Name", ...
+            
+            tracerproxy = libmexclass.proxy.Proxy("Name", ...
                 "libmexclass.opentelemetry.TracerProxy", "ID", id);
-    	    tracer = opentelemetry.trace.Tracer(tracerproxy, trname, trversion, trschema);
+            tracer = opentelemetry.trace.Tracer(tracerproxy, trname, trversion, trschema);
         end
 
         function setTracerProvider(obj)
@@ -142,5 +146,39 @@ function setTracerProvider(obj)
             %    See also OPENTELEMETRY.TRACE.PROVIDER.GETTRACERPROVIDER
             obj.Proxy.setTracerProvider();
         end
+
+        function success = shutdown(obj)
+            % SHUTDOWN  Shutdown 
+            %    SUCCESS = SHUTDOWN(TP) shuts down all span processors associated with tracer provider TP
+    	    %    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(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
+            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

sdk/trace/include/opentelemetry-matlab/sdk/trace/TracerProviderProxy.h

@@ -12,10 +12,16 @@ class TracerProviderProxy : public libmexclass::opentelemetry::TracerProviderPro
   public:
     TracerProviderProxy(nostd::shared_ptr<trace_api::TracerProvider> tp) : libmexclass::opentelemetry::TracerProviderProxy(tp) {
         REGISTER_METHOD(TracerProviderProxy, addSpanProcessor);
+        REGISTER_METHOD(TracerProviderProxy, shutdown);
+        REGISTER_METHOD(TracerProviderProxy, forceFlush);
     }
 
     static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
 
     void addSpanProcessor(libmexclass::proxy::method::Context& context);
+
+    void shutdown(libmexclass::proxy::method::Context& context);
+
+    void forceFlush(libmexclass::proxy::method::Context& context);
 };
 } // namespace libmexclass::opentelemetry

sdk/trace/src/TracerProviderProxy.cpp

@@ -11,12 +11,14 @@
 #include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/trace/tracer_provider.h"
+#include "opentelemetry/trace/noop.h"
 #include "opentelemetry/common/key_value_iterable_view.h"
 
 namespace trace_api = opentelemetry::trace;
 namespace trace_sdk = opentelemetry::sdk::trace;
 namespace resource = opentelemetry::sdk::resource;
 namespace common_sdk = opentelemetry::sdk::common;
+namespace nostd = opentelemetry::nostd;
 
 namespace libmexclass::opentelemetry::sdk {
 libmexclass::proxy::MakeResult TracerProviderProxy::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
@@ -64,4 +66,23 @@ void TracerProviderProxy::addSpanProcessor(libmexclass::proxy::method::Context&
 			    libmexclass::proxy::ProxyManager::getProxy(processorid))->getInstance());
 }
 
+void TracerProviderProxy::shutdown(libmexclass::proxy::method::Context& context) {
+    matlab::data::ArrayFactory factory;
+    auto result_mda = factory.createScalar(static_cast<trace_sdk::TracerProvider&>(*CppTracerProvider).Shutdown());
+    context.outputs[0] = result_mda;
+    CppTracerProvider.swap(nostd::shared_ptr<trace_api::TracerProvider>(new trace_api::NoopTracerProvider));
+}
+
+void TracerProviderProxy::forceFlush(libmexclass::proxy::method::Context& context) {
+    matlab::data::ArrayFactory factory;
+
+    if (context.inputs.getNumberOfElements() == 0) {
+        context.outputs[0] = factory.createScalar(static_cast<trace_sdk::TracerProvider&>(*CppTracerProvider).ForceFlush());
+    } else {  // number of inputs > 0
+        matlab::data::TypedArray<double> timeout_mda = context.inputs[0];
+        auto timeout = std::chrono::microseconds(timeout_mda[0]);
+        context.outputs[0] = factory.createScalar(static_cast<trace_sdk::TracerProvider&>(*CppTracerProvider).ForceFlush(timeout));
+    }
+}
+
 } // namespace libmexclass::opentelemetry