gaborcsardi · Oct 31, 2026 · Oct 31, 2026
diff --git a/NEWS.md b/NEWS.md
@@ -1,5 +1,10 @@
 # otelsdk (development version)
 
+* All tracer and logger providers now have a `shutdown()` method, like
+  meter providers already had. `flush()` now works for
+  `tracer_provider_memory` and `logger_provider_http`; previously it did
+  nothing (#32).
+
 * Methods of tracer, logger, meter, context, span instrument (counter,
   up-down counter, histogram, gauge) and provider objects do not throw
   errors any more. On failure they emit an `otel_error_message` message and

diff --git a/R/api-dev.R b/R/api-dev.R
@@ -25,6 +25,10 @@ logger_provider_file_new_dev <- function(opts = NULL) {
     },
     flush = function() {
         ccall(otel_logger_provider_flush, self$xptr)
+    },
+    shutdown = function() {
+        ccall(otel_logger_provider_shutdown, self$xptr)
+      invisible(self)
     }
   )
 
@@ -55,7 +59,11 @@ logger_provider_http_new_dev <- function(opts = NULL) {
         )
     },
     flush = function() {
-      # noop currenrly
+        ccall(otel_logger_provider_flush, self$xptr)
+    },
+    shutdown = function() {
+        ccall(otel_logger_provider_shutdown, self$xptr)
+      invisible(self)
     }
   )
 
@@ -89,6 +97,10 @@ logger_provider_stdstream_new_dev <- function(opts = NULL) {
     },
     flush = function() {
         ccall(otel_logger_provider_flush, self$xptr)
+    },
+    shutdown = function() {
+        ccall(otel_logger_provider_shutdown, self$xptr)
+      invisible(self)
     }
   )
 
@@ -740,6 +752,10 @@ tracer_provider_file_new_dev <- function(opts = NULL) {
     },
     flush = function() {
         ccall(otel_tracer_provider_flush, self$xptr)
+    },
+    shutdown = function() {
+        ccall(otel_tracer_provider_shutdown, self$xptr)
+      invisible(self)
     }
   )
 
@@ -763,6 +779,10 @@ tracer_provider_http_new_dev <- function(opts = NULL) {
     },
     flush = function() {
         ccall(otel_tracer_provider_flush, self$xptr)
+    },
+    shutdown = function() {
+        ccall(otel_tracer_provider_shutdown, self$xptr)
+      invisible(self)
     }
   )
 
@@ -785,7 +805,11 @@ tracer_provider_memory_new_dev <- function(opts = NULL) {
         tracer_new(self, name, version, schema_url, attributes, ...)
     },
     flush = function() {
-      # noop currently
+        ccall(otel_tracer_provider_flush, self$xptr)
+    },
+    shutdown = function() {
+        ccall(otel_tracer_provider_shutdown, self$xptr)
+      invisible(self)
     },
     get_spans = function() {
         spans <- ccall(otel_tracer_provider_memory_get_spans, self$xptr)
@@ -814,6 +838,10 @@ tracer_provider_stdstream_new_dev <- function(opts = NULL) {
     },
     flush = function() {
         ccall(otel_tracer_provider_flush, self$xptr)
+    },
+    shutdown = function() {
+        ccall(otel_tracer_provider_shutdown, self$xptr)
+      invisible(self)
     }
   )
   attributes <- as_otel_attributes(the$default_resource_attributes)

diff --git a/R/logger-provider-file.R b/R/logger-provider-file.R
@@ -36,6 +36,14 @@ logger_provider_file_new <- function(opts = NULL) {
         errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
         invisible(NULL)                                              # safe
       })                                                             # safe
+    },
+    shutdown = function() {
+      tryCatch({                                                     # safe
+        ccall(otel_logger_provider_shutdown, self$xptr)
+      }, error = function(err) {                                     # safe
+        errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
+      })                                                             # safe
+      invisible(self)
     }
   )
 

diff --git a/R/logger-provider-http.R b/R/logger-provider-http.R
@@ -29,7 +29,20 @@ logger_provider_http_new <- function(opts = NULL) {
       })                                                             # safe
     },
     flush = function() {
-      # noop currenrly
+      tryCatch({                                                     # safe
+        ccall(otel_logger_provider_flush, self$xptr)
+      }, error = function(err) {                                     # safe
+        errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
+        invisible(NULL)                                              # safe
+      })                                                             # safe
+    },
+    shutdown = function() {
+      tryCatch({                                                     # safe
+        ccall(otel_logger_provider_shutdown, self$xptr)
+      }, error = function(err) {                                     # safe
+        errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
+      })                                                             # safe
+      invisible(self)
     }
   )
 

diff --git a/R/logger-provider-stdout.R b/R/logger-provider-stdout.R
@@ -36,6 +36,14 @@ logger_provider_stdstream_new <- function(opts = NULL) {
         errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
         invisible(NULL)                                              # safe
       })                                                             # safe
+    },
+    shutdown = function() {
+      tryCatch({                                                     # safe
+        ccall(otel_logger_provider_shutdown, self$xptr)
+      }, error = function(err) {                                     # safe
+        errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
+      })                                                             # safe
+      invisible(self)
     }
   )
 

diff --git a/R/tracer-provider-file.R b/R/tracer-provider-file.R
@@ -27,6 +27,14 @@ tracer_provider_file_new <- function(opts = NULL) {
         errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
         invisible(NULL)                                              # safe
       })                                                             # safe
+    },
+    shutdown = function() {
+      tryCatch({                                                     # safe
+        ccall(otel_tracer_provider_shutdown, self$xptr)
+      }, error = function(err) {                                     # safe
+        errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
+      })                                                             # safe
+      invisible(self)
     }
   )
 

diff --git a/R/tracer-provider-http.R b/R/tracer-provider-http.R
@@ -26,6 +26,14 @@ tracer_provider_http_new <- function(opts = NULL) {
         errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
         invisible(NULL)                                              # safe
       })                                                             # safe
+    },
+    shutdown = function() {
+      tryCatch({                                                     # safe
+        ccall(otel_tracer_provider_shutdown, self$xptr)
+      }, error = function(err) {                                     # safe
+        errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
+      })                                                             # safe
+      invisible(self)
     }
   )
 

diff --git a/R/tracer-provider-memory.R b/R/tracer-provider-memory.R
@@ -20,7 +20,20 @@ tracer_provider_memory_new <- function(opts = NULL) {
       })                                                             # safe
     },
     flush = function() {
-      # noop currently
+      tryCatch({                                                     # safe
+        ccall(otel_tracer_provider_flush, self$xptr)
+      }, error = function(err) {                                     # safe
+        errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
+        invisible(NULL)                                              # safe
+      })                                                             # safe
+    },
+    shutdown = function() {
+      tryCatch({                                                     # safe
+        ccall(otel_tracer_provider_shutdown, self$xptr)
+      }, error = function(err) {                                     # safe
+        errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
+      })                                                             # safe
+      invisible(self)
     },
     get_spans = function() {
       tryCatch({                                                     # safe

diff --git a/R/tracer-provider-stdout.R b/R/tracer-provider-stdout.R
@@ -26,6 +26,14 @@ tracer_provider_stdstream_new <- function(opts = NULL) {
         errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
         invisible(NULL)                                              # safe
       })                                                             # safe
+    },
+    shutdown = function() {
+      tryCatch({                                                     # safe
+        ccall(otel_tracer_provider_shutdown, self$xptr)
+      }, error = function(err) {                                     # safe
+        errmsg("OpenTelemetry error: ", conditionMessage(err))       # safe
+      })                                                             # safe
+      invisible(self)
     }
   )
   attributes <- as_otel_attributes(the$default_resource_attributes)

diff --git a/src/init.c b/src/init.c
@@ -28,6 +28,7 @@ SEXP otel_create_tracer_provider_file(SEXP options, SEXP attributes);
 SEXP otel_tracer_provider_file_options_defaults(void);
 SEXP otel_tracer_provider_memory_get_spans(SEXP provider);
 SEXP otel_tracer_provider_flush(SEXP provider);
+SEXP otel_tracer_provider_shutdown(SEXP provider);
 SEXP otel_get_tracer(
   SEXP provider, SEXP name, SEXP version, SEXP schema_url,
   SEXP attributes);
@@ -77,6 +78,7 @@ SEXP otel_get_logger(
   SEXP provider, SEXP name, SEXP minimum_severity, SEXP version,
   SEXP schema_url, SEXP attributes);
 SEXP otel_logger_provider_flush(SEXP provider);
+SEXP otel_logger_provider_shutdown(SEXP provider);
 
 SEXP otel_get_minimum_log_severity(SEXP logger);
 SEXP otel_set_minimum_log_severity(SEXP logger, SEXP mimimum_severity);
@@ -151,6 +153,7 @@ static const R_CallMethodDef callMethods[]  = {
   CALLDEF(otel_tracer_provider_file_options_defaults, 0),
   CALLDEF(otel_tracer_provider_memory_get_spans, 1),
   CALLDEF(otel_tracer_provider_flush, 1),
+  CALLDEF(otel_tracer_provider_shutdown, 1),
   CALLDEF(otel_get_tracer, 5),
   CALLDEF(otel_get_active_span_context, 1),
   CALLDEF(otel_get_active_span, 1),
@@ -191,6 +194,7 @@ static const R_CallMethodDef callMethods[]  = {
   CALLDEF(otel_get_minimum_log_severity, 1),
   CALLDEF(otel_set_minimum_log_severity, 2),
   CALLDEF(otel_logger_provider_flush, 1),
+  CALLDEF(otel_logger_provider_shutdown, 1),
   CALLDEF(otel_get_logger, 6),
   CALLDEF(otel_logger_get_name, 1),
   CALLDEF(otel_emit_log_record, 2),

diff --git a/src/logger-sdk.cc b/src/logger-sdk.cc
@@ -64,14 +64,26 @@ void otel_logger_provider_file_options_defaults_(
   cc2c_file_exporter_options(backend_opts, *options);
 }
 
-void otel_logger_provider_flush_(void *logger_provider_) {
+int otel_logger_provider_flush_(void *logger_provider_) {
   struct otel_logger_provider *lps =
     (struct otel_logger_provider *) logger_provider_;
+  logs_sdk::LoggerProvider &logger_provider = *(lps->ptr);
+  int res = logger_provider.ForceFlush();
   if (lps->stream.is_open()) {
     lps->stream.flush();
   }
+  return res;
+}
+
+int otel_logger_provider_shutdown_(void *logger_provider_) {
+  struct otel_logger_provider *lps =
+    (struct otel_logger_provider *) logger_provider_;
   logs_sdk::LoggerProvider &logger_provider = *(lps->ptr);
-  logger_provider.ForceFlush();
+  int res = logger_provider.Shutdown();
+  if (lps->stream.is_open()) {
+    lps->stream.flush();
+  }
+  return res;
 }
 
 int otel_get_minimum_log_severity_(void *logger_) {

diff --git a/src/logger.c b/src/logger.c
@@ -122,6 +122,24 @@ SEXP otel_logger_provider_flush(SEXP provider) {
   return R_NilValue;
 }
 
+SEXP otel_logger_provider_shutdown(SEXP provider) {
+  if (TYPEOF(provider) != EXTPTRSXP) {
+    Rf_warningcall(
+      R_NilValue,
+      "OpenTelemetry: invalid logger provider pointer."
+    );
+    return R_NilValue;
+  }
+  void *logger_provider_ = R_ExternalPtrAddr(provider);
+  if (!logger_provider_) {
+    Rf_error(
+      "Opentelemetry logger provider cleaned up already, internal error."
+    );
+  }
+  int res = otel_logger_provider_shutdown_(logger_provider_);
+  return Rf_ScalarLogical(res);
+}
+
 SEXP otel_get_logger(
     SEXP provider, SEXP name, SEXP minimum_severity, SEXP version,
     SEXP schema_url, SEXP attributes) {

diff --git a/src/otel_common.h b/src/otel_common.h
@@ -577,6 +577,7 @@ void otel_tracer_provider_file_options_defaults_(
 int otel_tracer_provider_memory_get_spans_(
   void *tracer_provider, struct otel_span_data *cdata);
 int otel_tracer_provider_flush_(void *tracer_provider);
+int otel_tracer_provider_shutdown_(void *tracer_provider);
 void *otel_get_tracer_(
     void *tracer_provider_, const char *name, const char *version,
     const char *schema_url, struct otel_attributes *attributes);
@@ -649,7 +650,8 @@ void *otel_create_logger_provider_file_(
   struct otel_file_exporter_options *options);
 void otel_logger_provider_file_options_defaults_(
   struct otel_file_exporter_options *options);
-void otel_logger_provider_flush_(void *tracer_provider);
+int otel_logger_provider_flush_(void *logger_provider);
+int otel_logger_provider_shutdown_(void *logger_provider);
 int otel_get_minimum_log_severity_(void *logger);
 void otel_set_minimum_log_severity_(void *logger, int minimum_severity);
 void *otel_get_logger_(

diff --git a/src/tracer-sdk.cc b/src/tracer-sdk.cc
@@ -203,11 +203,23 @@ int otel_tracer_provider_memory_get_spans_(
 int otel_tracer_provider_flush_(void *tracer_provider_) {
   struct otel_tracer_provider *tps =
     (struct otel_tracer_provider *) tracer_provider_;
+  trace_sdk::TracerProvider &tracer_provider = *(tps->ptr);
+  int res = tracer_provider.ForceFlush();
   if (tps->stream.is_open()) {
     tps->stream.flush();
   }
+  return res;
+}
+
+int otel_tracer_provider_shutdown_(void *tracer_provider_) {
+  struct otel_tracer_provider *tps =
+    (struct otel_tracer_provider *) tracer_provider_;
   trace_sdk::TracerProvider &tracer_provider = *(tps->ptr);
-  return tracer_provider.ForceFlush();
+  int res = tracer_provider.Shutdown();
+  if (tps->stream.is_open()) {
+    tps->stream.flush();
+  }
+  return res;
 }
 
 void *otel_get_tracer_(

diff --git a/src/tracer.c b/src/tracer.c
@@ -137,6 +137,24 @@ SEXP otel_tracer_provider_flush(SEXP provider) {
   return Rf_ScalarLogical(res);
 }
 
+SEXP otel_tracer_provider_shutdown(SEXP provider) {
+  if (TYPEOF(provider) != EXTPTRSXP) {
+    Rf_warningcall(
+      R_NilValue,
+      "OpenTelemetry: invalid tracer provider pointer."
+    );
+    return R_NilValue;
+  }
+  void *tracer_provider_ = R_ExternalPtrAddr(provider);
+  if (!tracer_provider_) {
+    Rf_error(
+      "Opentelemetry tracer provider cleaned up already, internal error."
+    );
+  }
+  int res = otel_tracer_provider_shutdown_(tracer_provider_);
+  return Rf_ScalarLogical(res);
+}
+
 SEXP otel_get_tracer(
     SEXP provider, SEXP name, SEXP version, SEXP schema_url,
     SEXP attributes) {

diff --git a/tests/testthat/_snaps/logger.md b/tests/testthat/_snaps/logger.md
@@ -47,6 +47,21 @@
       Error:
       ! Opentelemetry logger provider cleaned up already, internal error.
 
+# otel_logger_provider_shutdown
+
+    Code
+      ccall(otel_logger_provider_shutdown, 1L)
+    Condition
+      Warning:
+      OpenTelemetry: invalid logger provider pointer.
+    Output
+      NULL
+    Code
+      ccall(otel_logger_provider_shutdown, x)
+    Condition
+      Error:
+      ! Opentelemetry logger provider cleaned up already, internal error.
+
 # otel_get_logger
 
     Code