Add default logger for TRT logger

Author: chilo-ms

plugin_execution_providers/tensorrt/onnx_ctx_model_helper.cc

@@ -9,7 +9,8 @@
 #include "onnx_ctx_model_helper.h"
 #include "onnx/onnx_pb.h"
 
-extern TensorrtLogger& GetTensorrtLogger(bool verbose_log);
+extern TensorrtLogger& GetTensorrtLogger(bool verbose_log, const OrtLogger& ort_default_logger,
+                                         const OrtApi* ort_api);
 
 /*
  *  Check whether the graph has the EP context node.

plugin_execution_providers/tensorrt/tensorrt_execution_provider.cc

@@ -84,9 +84,11 @@ void OutputAllocator::notifyShape(char const* /*tensorName*/, nvinfer1::Dims con
   }
 }
 
-TensorrtLogger& GetTensorrtLogger(bool verbose_log) {
+TensorrtLogger& GetTensorrtLogger(bool verbose_log,
+                                  const OrtLogger& ort_default_logger,
+                                  const OrtApi* ort_api) {
   const auto log_level = verbose_log ? nvinfer1::ILogger::Severity::kVERBOSE : nvinfer1::ILogger::Severity::kWARNING;
-  static TensorrtLogger trt_logger(log_level);
+  static TensorrtLogger trt_logger(ort_default_logger, ort_api, log_level);
   if (log_level != trt_logger.get_level()) {
     trt_logger.set_level(verbose_log ? nvinfer1::ILogger::Severity::kVERBOSE : nvinfer1::ILogger::Severity::kWARNING);
   }
@@ -1041,7 +1043,7 @@ OrtStatus* TensorrtExecutionProvider::CreateNodeComputeInfoFromGraph(OrtEp* this
     model_proto.SerializeToOstream(&dump);
   }
 
-  TensorrtLogger& trt_logger = GetTensorrtLogger(detailed_build_log_);
+  TensorrtLogger& trt_logger = GetTensorrtLogger(detailed_build_log_, logger_, &ort_api);
   auto trt_builder = GetBuilder(trt_logger);
   auto network_flags = 0;
 #if NV_TENSORRT_MAJOR > 8
@@ -2021,7 +2023,7 @@ OrtStatus* TensorrtExecutionProvider::RefitEngine(
   }
 
   // weight-stripped engine refit logic
-  TensorrtLogger& trt_logger = GetTensorrtLogger(detailed_build_log);
+  TensorrtLogger& trt_logger = GetTensorrtLogger(detailed_build_log, logger_, &ort_api);
   auto refitter = std::unique_ptr<nvinfer1::IRefitter>(nvinfer1::createInferRefitter(*trt_engine, trt_logger));
   auto parser_refitter =
       std::unique_ptr<nvonnxparser::IParserRefitter>(nvonnxparser::createParserRefitter(*refitter, trt_logger));
@@ -2378,7 +2380,7 @@ TensorrtExecutionProvider::TensorrtExecutionProvider(TensorrtExecutionProviderFa
 
   {
     auto lock = GetApiLock();
-    runtime_ = std::unique_ptr<nvinfer1::IRuntime>(nvinfer1::createInferRuntime(GetTensorrtLogger(detailed_build_log_)));
+    runtime_ = std::unique_ptr<nvinfer1::IRuntime>(nvinfer1::createInferRuntime(GetTensorrtLogger(detailed_build_log_, logger_, &ort_api)));
   }
 
   // EP Context setting

plugin_execution_providers/tensorrt/tensorrt_execution_provider.h

@@ -66,10 +66,14 @@ using DestroyFunc = void (*)(void*, void*);
 
 class TensorrtLogger : public nvinfer1::ILogger {
   nvinfer1::ILogger::Severity verbosity_;
+  const OrtLogger& ort_default_logger_;
+  const OrtApi* ort_api_ = nullptr;
 
  public:
-  TensorrtLogger(Severity verbosity = Severity::kWARNING)
-      : verbosity_(verbosity) {}
+  TensorrtLogger(const OrtLogger& ort_default_logger,
+                 const OrtApi* ort_api,
+                 Severity verbosity = Severity::kWARNING)
+      : ort_default_logger_{ort_default_logger}, ort_api_{ort_api}, verbosity_(verbosity) {}
   void log(Severity severity, const char* msg) noexcept override {
     if (severity <= verbosity_) {
       time_t rawtime = std::time(0);
@@ -87,11 +91,19 @@ class TensorrtLogger : public nvinfer1::ILogger {
                                                                             : severity == Severity::kWARNING ? "WARNING"
                                                                             : severity == Severity::kINFO    ? "   INFO"
                                                                                                              : "UNKNOWN");
+      OrtLoggingLevel ort_severity;
       if (severity <= Severity::kERROR) {
-        // LOGS_DEFAULT(ERROR) << "[" << buf << " " << sevstr << "] " << msg;
-      } else {
-        // LOGS_DEFAULT(WARNING) << "[" << buf << " " << sevstr << "] " << msg;
+        ort_severity = ORT_LOGGING_LEVEL_ERROR;
       }
+      else {
+        ort_severity = ORT_LOGGING_LEVEL_WARNING;
+      }
+
+      std::string message = "[" + std::string(buf) + " " + std::string(sevstr) + "] " + std::string(msg);
+
+      Ort::ThrowOnError(ort_api_->Logger_LogMessage(&ort_default_logger_,
+                                                    ort_severity,
+                                                    message.c_str(), ORT_FILE, __LINE__, __FUNCTION__));
     }
   }
   void set_level(Severity verbosity) {

plugin_execution_providers/tensorrt/tensorrt_provider_factory.cc

@@ -11,8 +11,8 @@
 #include <unordered_map>
 #include <vector>
 
-TensorrtExecutionProviderFactory::TensorrtExecutionProviderFactory(const char* ep_name, ApiPtrs apis)
-    : ApiPtrs(apis), ep_name_{ep_name} {
+TensorrtExecutionProviderFactory::TensorrtExecutionProviderFactory(const char* ep_name, const OrtLogger& default_logger, ApiPtrs apis)
+    : ApiPtrs(apis), default_logger_{default_logger}, ep_name_{ep_name} {
   ort_version_supported = ORT_API_VERSION;  // set to the ORT version we were compiled with.
   GetName = GetNameImpl;
   GetVendor = GetVendorImpl;
@@ -280,14 +280,14 @@ extern "C" {
 // Public symbols
 //
 EXPORT_SYMBOL OrtStatus* CreateEpFactories(const char* registration_name, const OrtApiBase* ort_api_base,
-                                           const OrtLogger*,
+                                           const OrtLogger* default_logger,
                                            OrtEpFactory** factories, size_t max_factories, size_t* num_factories) {
   const OrtApi* ort_api = ort_api_base->GetApi(ORT_API_VERSION);
   const OrtEpApi* ort_ep_api = ort_api->GetEpApi();
   const OrtModelEditorApi* model_editor_api = ort_api->GetModelEditorApi();
 
   // Factory could use registration_name or define its own EP name.
-  std::unique_ptr<OrtEpFactory> factory = std::make_unique<TensorrtExecutionProviderFactory>(registration_name, ApiPtrs{*ort_api, *ort_ep_api, *model_editor_api});
+  std::unique_ptr<OrtEpFactory> factory = std::make_unique<TensorrtExecutionProviderFactory>(registration_name, *default_logger, ApiPtrs{*ort_api, *ort_ep_api, *model_editor_api});
 
   if (max_factories < 1) {
     return ort_api->CreateStatus(ORT_INVALID_ARGUMENT,

plugin_execution_providers/tensorrt/tensorrt_provider_factory.h

@@ -11,7 +11,7 @@ using MemoryInfoUniquePtr = std::unique_ptr<OrtMemoryInfo, std::function<void(Or
 ///
 struct TensorrtExecutionProviderFactory : public OrtEpFactory, public ApiPtrs {
  public:
-  TensorrtExecutionProviderFactory(const char* ep_name, ApiPtrs apis);
+  TensorrtExecutionProviderFactory(const char* ep_name, const OrtLogger& default_logger, ApiPtrs apis);
 
   OrtStatus* CreateMemoryInfoForDevices(int num_devices);
 
@@ -62,4 +62,5 @@ struct TensorrtExecutionProviderFactory : public OrtEpFactory, public ApiPtrs {
   const std::string ep_name_;              // EP name
   const std::string vendor_{"Nvidia"};     // EP vendor name
   const std::string ep_version_{"0.1.0"};  // EP version
+  const OrtLogger& default_logger_;
 };