Add telemetry event for auto ep selection (#25243)

This pull request introduces telemetry enhancements for logging
execution provider (EP) auto-selection events in ONNX Runtime. The
changes include adding new methods to log EP selection data, updating
classes to support session ID retrieval, and integrating telemetry
logging into the session provider policy context.

### Telemetry Enhancements:
* **Added `LogAutoEpSelection` Method**: Introduced a new virtual method
in `Telemetry` and its override in `WindowsTelemetry` to log
session-specific EP auto-selection data, including requested and
available EP IDs and selection policies.

### Session ID Support:
* **Added `GetCurrentSessionId` Method**: Added a method to
`InferenceSession` to retrieve the current session ID, enabling
session-specific telemetry logging.

### Integration with Provider Policy Context:
* **Telemetry Logging in EP Selection**: Integrated telemetry logging
into `ProviderPolicyContext::SelectEpsForSession`, capturing requested
and available EP IDs, along with the selection policy type, and invoking
the telemetry provider's `LogAutoEpSelection` method.

Author: ashrit-ms

onnxruntime/core/platform/telemetry.cc

@@ -107,4 +107,13 @@ void Telemetry::LogDriverInfoEvent(const std::string_view device_class,
   ORT_UNUSED_PARAMETER(driver_versions);
 }
 
+void Telemetry::LogAutoEpSelection(uint32_t session_id, const std::string& selection_policy,
+                                   const std::vector<std::string>& requested_execution_provider_ids,
+                                   const std::vector<std::string>& available_execution_provider_ids) const {
+  ORT_UNUSED_PARAMETER(session_id);
+  ORT_UNUSED_PARAMETER(selection_policy);
+  ORT_UNUSED_PARAMETER(requested_execution_provider_ids);
+  ORT_UNUSED_PARAMETER(available_execution_provider_ids);
+}
+
 }  // namespace onnxruntime

onnxruntime/core/platform/telemetry.h

@@ -78,6 +78,10 @@ class Telemetry {
                                   const std::wstring_view& driver_names,
                                   const std::wstring_view& driver_versions) const;
 
+  virtual void LogAutoEpSelection(uint32_t session_id, const std::string& selection_policy,
+                                  const std::vector<std::string>& requested_execution_provider_ids,
+                                  const std::vector<std::string>& available_execution_provider_ids) const;
+
  private:
   ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(Telemetry);
 };

onnxruntime/core/platform/windows/telemetry.cc

@@ -433,4 +433,49 @@ void WindowsTelemetry::LogDriverInfoEvent(const std::string_view device_class, c
                     TraceLoggingWideString(driver_versions.data(), "driverVersions"));
 }
 
+void WindowsTelemetry::LogAutoEpSelection(uint32_t session_id, const std::string& selection_policy,
+                                          const std::vector<std::string>& requested_execution_provider_ids,
+                                          const std::vector<std::string>& available_execution_provider_ids) const {
+  if (global_register_count_ == 0 || enabled_ == false)
+    return;
+
+  // Build requested execution provider string
+  std::string requested_execution_provider_string;
+  bool first = true;
+  for (const auto& ep_id : requested_execution_provider_ids) {
+    if (first) {
+      first = false;
+    } else {
+      requested_execution_provider_string += ',';
+    }
+    requested_execution_provider_string += ep_id;
+  }
+
+  // Build available execution provider string
+  std::string available_execution_provider_string;
+  first = true;
+  for (const auto& ep_id : available_execution_provider_ids) {
+    if (first) {
+      first = false;
+    } else {
+      available_execution_provider_string += ',';
+    }
+    available_execution_provider_string += ep_id;
+  }
+
+  TraceLoggingWrite(telemetry_provider_handle,
+                    "EpAutoSelection",
+                    TraceLoggingBool(true, "UTCReplace_AppSessionGuid"),
+                    TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage),
+                    TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+                    TraceLoggingKeyword(static_cast<uint64_t>(onnxruntime::logging::ORTTraceLoggingKeyword::Session)),
+                    TraceLoggingLevel(WINEVENT_LEVEL_INFO),
+                    // Telemetry info
+                    TraceLoggingUInt8(0, "schemaVersion"),
+                    TraceLoggingUInt32(session_id, "sessionId"),
+                    TraceLoggingString(selection_policy.c_str(), "selectionPolicy"),
+                    TraceLoggingString(requested_execution_provider_string.c_str(), "requestedExecutionProviderIds"),
+                    TraceLoggingString(available_execution_provider_string.c_str(), "availableExecutionProviderIds"));
+}
+
 }  // namespace onnxruntime

onnxruntime/core/platform/windows/telemetry.h

@@ -71,6 +71,10 @@ class WindowsTelemetry : public Telemetry {
                           const std::wstring_view& driver_names,
                           const std::wstring_view& driver_versions) const override;
 
+  void LogAutoEpSelection(uint32_t session_id, const std::string& selection_policy,
+                          const std::vector<std::string>& requested_execution_provider_ids,
+                          const std::vector<std::string>& available_execution_provider_ids) const override;
+
   using EtwInternalCallback = std::function<void(LPCGUID SourceId, ULONG IsEnabled, UCHAR Level,
                                                  ULONGLONG MatchAnyKeyword, ULONGLONG MatchAllKeyword,
                                                  PEVENT_FILTER_DESCRIPTOR FilterData, PVOID CallbackContext)>;

onnxruntime/core/session/inference_session.h

@@ -630,6 +630,10 @@ class InferenceSession {
     return weight_hash_;
   }
 
+  uint32_t GetCurrentSessionId() const {
+    return session_id_;
+  }
+
  protected:
 #if !defined(ORT_MINIMAL_BUILD)
 

onnxruntime/core/session/provider_policy_context.cc

@@ -214,6 +214,64 @@ Status ProviderPolicyContext::SelectEpsForSession(const Environment& env, const
                            "No execution providers selected. Please check the device policy and available devices.");
   }
 
+  // Log telemetry for auto EP selection
+  {
+    std::vector<std::string> requested_ep_ids;
+    requested_ep_ids.reserve(devices_selected.size());
+
+    for (const auto* device : devices_selected) {
+      if (device != nullptr) {
+        requested_ep_ids.push_back(device->ep_name);
+      }
+    }
+
+    // Extract available execution provider IDs
+    std::vector<std::string> available_ep_ids;
+    available_ep_ids.reserve(execution_devices.size());
+    for (const auto* device : execution_devices) {
+      available_ep_ids.push_back(device->ep_name);
+    }
+
+    std::string policy_type;
+    if (options.value.ep_selection_policy.delegate) {
+      policy_type = "custom_delegate";
+    } else {
+      switch (options.value.ep_selection_policy.policy) {
+        case OrtExecutionProviderDevicePolicy_DEFAULT:
+          policy_type = "DEFAULT";
+          break;
+        case OrtExecutionProviderDevicePolicy_PREFER_CPU:
+          policy_type = "PREFER_CPU";
+          break;
+        case OrtExecutionProviderDevicePolicy_PREFER_NPU:
+          policy_type = "PREFER_NPU";
+          break;
+        case OrtExecutionProviderDevicePolicy_PREFER_GPU:
+          policy_type = "PREFER_GPU";
+          break;
+        case OrtExecutionProviderDevicePolicy_MAX_PERFORMANCE:
+          policy_type = "MAX_PERFORMANCE";
+          break;
+        case OrtExecutionProviderDevicePolicy_MAX_EFFICIENCY:
+          policy_type = "MAX_EFFICIENCY";
+          break;
+        case OrtExecutionProviderDevicePolicy_MIN_OVERALL_POWER:
+          policy_type = "MIN_OVERALL_POWER";
+          break;
+        default:
+          policy_type = "UNKNOWN";
+          break;
+      }
+    }
+
+    const Env& os_env = Env::Default();
+    os_env.GetTelemetryProvider().LogAutoEpSelection(
+        sess.GetCurrentSessionId(),
+        policy_type,
+        requested_ep_ids,
+        available_ep_ids);
+  }
+
   // Configure the session options for the devices. This updates the SessionOptions in the InferenceSession with any
   // EP options that have not been overridden by the user.
   ORT_RETURN_IF_ERROR(AddEpDefaultOptionsToSession(sess, devices_selected));