diff --git a/Directory.Packages.props b/Directory.Packages.props
index f37bd594e4c..8d1be8d06bb 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -19,6 +19,7 @@
     <PackageVersion Include="Microsoft.Extensions.Logging" Version="$(MicrosoftExtensionsLoggingVersion)" />
     <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="$(MicrosoftExtensionsLoggingAbstractionsVersion)" />
     <PackageVersion Include="Microsoft.Extensions.Logging.Console" Version="$(MicrosoftExtensionsLoggingConsoleVersion)" />
+    <PackageVersion Include="Microsoft.Extensions.Options" Version="$(MicrosoftExtensionsOptionsVersion)" />
     <PackageVersion Include="Microsoft.FileFormats" Version="$(MicrosoftFileFormatsVersion)" />
     <PackageVersion Include="Microsoft.Identity.Web" Version="$(MicrosoftIdentityWebVersion)" />
     <PackageVersion Include="Microsoft.OpenApi.Readers" Version="$(MicrosoftOpenApiReadersVersion)" />
diff --git a/eng/Versions.props b/eng/Versions.props
index b8eea776951..4005cc092bc 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -86,6 +86,7 @@
     <MicrosoftExtensionsLoggingVersion>$(MicrosoftExtensionsLogging80Version)</MicrosoftExtensionsLoggingVersion>
     <MicrosoftExtensionsLoggingAbstractionsVersion>$(MicrosoftExtensionsLoggingAbstractions80Version)</MicrosoftExtensionsLoggingAbstractionsVersion>
     <MicrosoftExtensionsLoggingConsoleVersion>$(MicrosoftExtensionsLoggingConsole80Version)</MicrosoftExtensionsLoggingConsoleVersion>
+    <MicrosoftExtensionsOptionsVersion>$(MicrosoftExtensionsOptions80Version)</MicrosoftExtensionsOptionsVersion>
     <SystemTextJsonVersion>$(SystemTextJson80Version)</SystemTextJsonVersion>
   </PropertyGroup>
   <PropertyGroup Label=".NET 9 Dependent" Condition=" '$(TargetFramework)' == 'net9.0' ">
@@ -95,6 +96,7 @@
     <MicrosoftExtensionsLoggingVersion>$(MicrosoftExtensionsLogging90Version)</MicrosoftExtensionsLoggingVersion>
     <MicrosoftExtensionsLoggingAbstractionsVersion>$(MicrosoftExtensionsLoggingAbstractions90Version)</MicrosoftExtensionsLoggingAbstractionsVersion>
     <MicrosoftExtensionsLoggingConsoleVersion>$(MicrosoftExtensionsLoggingConsole90Version)</MicrosoftExtensionsLoggingConsoleVersion>
+    <MicrosoftExtensionsOptionsVersion>$(MicrosoftExtensionsOptions90Version)</MicrosoftExtensionsOptionsVersion>
     <SystemTextJsonVersion>$(SystemTextJson90Version)</SystemTextJsonVersion>
     <MicrosoftAspNetCoreOpenApiVersion>$(MicrosoftAspNetCoreApp90Version)</MicrosoftAspNetCoreOpenApiVersion>
   </PropertyGroup>
@@ -105,6 +107,7 @@
     <MicrosoftExtensionsLoggingVersion>$(MicrosoftNETCoreApp100Version)</MicrosoftExtensionsLoggingVersion>
     <MicrosoftExtensionsLoggingAbstractionsVersion>$(MicrosoftNETCoreApp100Version)</MicrosoftExtensionsLoggingAbstractionsVersion>
     <MicrosoftExtensionsLoggingConsoleVersion>$(MicrosoftNETCoreApp100Version)</MicrosoftExtensionsLoggingConsoleVersion>
+    <MicrosoftExtensionsOptionsVersion>$(MicrosoftNETCoreApp100Version)</MicrosoftExtensionsOptionsVersion>
     <SystemTextJsonVersion>$(MicrosoftNETCoreApp100Version)</SystemTextJsonVersion>
     <MicrosoftAspNetCoreOpenApiVersion>$(MicrosoftAspNetCoreApp100Version)</MicrosoftAspNetCoreOpenApiVersion>
   </PropertyGroup>
diff --git a/eng/dependabot/net8.0/Packages.props b/eng/dependabot/net8.0/Packages.props
index 039efe2cfb3..fc6c4e5c1e0 100644
--- a/eng/dependabot/net8.0/Packages.props
+++ b/eng/dependabot/net8.0/Packages.props
@@ -7,6 +7,7 @@
     <PackageReference Include="Microsoft.Extensions.Logging" Version="$(MicrosoftExtensionsLogging80Version)" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="$(MicrosoftExtensionsLoggingAbstractions80Version)" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="$(MicrosoftExtensionsLoggingConsole80Version)" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="$(MicrosoftExtensionsOptions80Version)" />
     <!--
       We want to update "Microsoft.NETCore.App.Runtime.*" but those packages are considered platform packages and cannot be added
       as a package reference. Use Microsoft.NETCore.DotNetHost instead which is released in lockstep with the runtime packages and
diff --git a/eng/dependabot/net8.0/Versions.props b/eng/dependabot/net8.0/Versions.props
index 0803cf4a0d0..a0c48f03ec2 100644
--- a/eng/dependabot/net8.0/Versions.props
+++ b/eng/dependabot/net8.0/Versions.props
@@ -9,6 +9,8 @@
     <MicrosoftExtensionsLoggingAbstractions80Version>8.0.3</MicrosoftExtensionsLoggingAbstractions80Version>
     <!-- Microsoft.Extensions.Logging.Console -->
     <MicrosoftExtensionsLoggingConsole80Version>8.0.1</MicrosoftExtensionsLoggingConsole80Version>
+    <!-- Microsoft.Extensions.Options -->
+    <MicrosoftExtensionsOptions80Version>8.0.2</MicrosoftExtensionsOptions80Version>
     <!-- Microsoft.NETCore.App -->
     <MicrosoftNETCoreApp80Version>8.0.15</MicrosoftNETCoreApp80Version>
     <!-- System.Text.Json -->
diff --git a/eng/dependabot/net9.0/Versions.props b/eng/dependabot/net9.0/Versions.props
index 8a7dfb77b34..5fc5de53c00 100644
--- a/eng/dependabot/net9.0/Versions.props
+++ b/eng/dependabot/net9.0/Versions.props
@@ -9,6 +9,8 @@
     <MicrosoftExtensionsLoggingAbstractions90Version>9.0.4</MicrosoftExtensionsLoggingAbstractions90Version>
     <!-- Microsoft.Extensions.Logging.Console -->
     <MicrosoftExtensionsLoggingConsole90Version>9.0.4</MicrosoftExtensionsLoggingConsole90Version>
+    <!-- Microsoft.Extensions.Options -->
+    <MicrosoftExtensionsOptions90Version>9.0.4</MicrosoftExtensionsOptions90Version>
     <!-- Microsoft.NETCore.App -->
     <MicrosoftNETCoreApp90Version>9.0.4</MicrosoftNETCoreApp90Version>
     <!-- System.Text.Json -->
diff --git a/src/Directory.Build.targets b/src/Directory.Build.targets
index b75f72b30b1..8a8355ce625 100644
--- a/src/Directory.Build.targets
+++ b/src/Directory.Build.targets
@@ -126,4 +126,14 @@
     </ItemGroup>
   </Target>
 
+  <!-- Disable options validation source generator, to let us use a checked-in copy
+       of generated sources that include a fix for https://github.com/dotnet/runtime/issues/115347 -->
+  <Target Name="DisableOptionsValidationGenerator"
+          BeforeTargets="CoreCompile"
+          Condition="'$(DisableOptionsValidationGenerator)' == 'true'">
+    <ItemGroup>
+      <Analyzer Remove="@(Analyzer)" Condition="'%(Filename)' == 'Microsoft.Extensions.Options.SourceGeneration'" />
+    </ItemGroup>
+  </Target>
+
 </Project>
diff --git a/src/Microsoft.Diagnostics.Monitoring.Extension.Common/EgressHelper.cs b/src/Microsoft.Diagnostics.Monitoring.Extension.Common/EgressHelper.cs
index 1136a5e4b3c..a00d0c0d30e 100644
--- a/src/Microsoft.Diagnostics.Monitoring.Extension.Common/EgressHelper.cs
+++ b/src/Microsoft.Diagnostics.Monitoring.Extension.Common/EgressHelper.cs
@@ -190,7 +190,6 @@ private static ServiceCollection CreateServices<TOptions>(ExtensionEgressPayload
                         .Build()
                         .Bind(options);
                 });
-            services.AddSingleton<IValidateOptions<TOptions>, DataAnnotationValidateOptions<TOptions>>();
 
             services.AddSingleton(new EgressProperties(payload.Properties));
 
diff --git a/src/Microsoft.Diagnostics.Monitoring.Extension.Common/Microsoft.Diagnostics.Monitoring.Extension.Common.csproj b/src/Microsoft.Diagnostics.Monitoring.Extension.Common/Microsoft.Diagnostics.Monitoring.Extension.Common.csproj
index 8879d6f8eb6..8c5c54fd3a7 100644
--- a/src/Microsoft.Diagnostics.Monitoring.Extension.Common/Microsoft.Diagnostics.Monitoring.Extension.Common.csproj
+++ b/src/Microsoft.Diagnostics.Monitoring.Extension.Common/Microsoft.Diagnostics.Monitoring.Extension.Common.csproj
@@ -9,10 +9,6 @@
     <IsShippingAssembly>true</IsShippingAssembly>
   </PropertyGroup>
 
-  <ItemGroup>
-    <Compile Include="..\Tools\dotnet-monitor\DataAnnotationValidateOptions.cs" Link="DataAnnotationValidateOptions.cs" />
-  </ItemGroup>
-
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.Diagnostics.Monitoring.AzureBlobStorageTests.UnitTests" />
     <InternalsVisibleTo Include="Microsoft.Diagnostics.Monitoring.S3StorageTests.UnitTests" />
diff --git a/src/Microsoft.Diagnostics.Monitoring.Options/FileSystemEgressProviderOptionsValidator.cs b/src/Microsoft.Diagnostics.Monitoring.Options/FileSystemEgressProviderOptionsValidator.cs
new file mode 100644
index 00000000000..7113f63b046
--- /dev/null
+++ b/src/Microsoft.Diagnostics.Monitoring.Options/FileSystemEgressProviderOptionsValidator.cs
@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Diagnostics.Tools.Monitor.Egress.FileSystem
+{
+    [OptionsValidator]
+    internal sealed partial class FileSystemEgressProviderOptionsValidator : IValidateOptions<FileSystemEgressProviderOptions>
+    {
+        IServiceProvider _serviceProvider;
+
+        public FileSystemEgressProviderOptionsValidator(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+    }
+}
diff --git a/src/Microsoft.Diagnostics.Monitoring.Options/GlobalCounterOptions.cs b/src/Microsoft.Diagnostics.Monitoring.Options/GlobalCounterOptions.cs
index c360b5184d1..5c213a302be 100644
--- a/src/Microsoft.Diagnostics.Monitoring.Options/GlobalCounterOptions.cs
+++ b/src/Microsoft.Diagnostics.Monitoring.Options/GlobalCounterOptions.cs
@@ -7,6 +7,8 @@
 using System.ComponentModel.DataAnnotations;
 using System.Globalization;
 using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.Diagnostics.Monitoring.WebApi
 {
@@ -48,23 +50,28 @@ public class GlobalProviderOptions
         public float? IntervalSeconds { get; set; }
     }
 
+    [OptionsValidator]
+    partial class GlobalProviderOptionsValidator : IValidateOptions<GlobalProviderOptions>
+    {
+    }
+
     partial class GlobalCounterOptions : IValidatableObject
     {
         public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
         {
+            var providerValidator = validationContext.GetRequiredService<IValidateOptions<GlobalProviderOptions>>();
             var results = new List<ValidationResult>();
 
             if (Providers != null)
             {
-                var providerResults = new List<ValidationResult>();
                 foreach ((string provider, GlobalProviderOptions options) in Providers)
                 {
-                    providerResults.Clear();
-                    if (!Validator.TryValidateObject(options, new ValidationContext(options), providerResults, true))
+                    ValidateOptionsResult providerResults = providerValidator.Validate(provider, options);
+                    if (providerResults.Failed)
                     {
                         // We prefix the validation error with the provider.
-                        results.AddRange(providerResults.Select(r => new ValidationResult(
-                            string.Format(CultureInfo.CurrentCulture, OptionsDisplayStrings.ErrorMessage_NestedProviderValidationError, provider, r.ErrorMessage))));
+                        results.AddRange(providerResults.Failures.Select(r => new ValidationResult(
+                            string.Format(CultureInfo.CurrentCulture, OptionsDisplayStrings.ErrorMessage_NestedProviderValidationError, provider, r))));
                     }
                 }
             }
@@ -73,6 +80,17 @@ public IEnumerable<ValidationResult> Validate(ValidationContext validationContex
         }
     }
 
+    [OptionsValidator]
+    partial class GlobalCounterOptionsValidator : IValidateOptions<GlobalCounterOptions>
+    {
+        private readonly IServiceProvider _serviceProvider;
+
+        public GlobalCounterOptionsValidator(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+    }
+
     internal static class GlobalCounterOptionsExtensions
     {
         public static float GetIntervalSeconds(this GlobalCounterOptions options) =>
diff --git a/src/Microsoft.Diagnostics.Monitoring.Options/MetricsOptions.cs b/src/Microsoft.Diagnostics.Monitoring.Options/MetricsOptions.cs
index faa647690f3..7d7b5a9e9d7 100644
--- a/src/Microsoft.Diagnostics.Monitoring.Options/MetricsOptions.cs
+++ b/src/Microsoft.Diagnostics.Monitoring.Options/MetricsOptions.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -43,6 +44,7 @@ public class MetricsOptions
         [Display(
             ResourceType = typeof(OptionsDisplayStrings),
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_MetricsOptions_Providers))]
+        [ValidateEnumeratedItems]
         public List<MetricProvider> Providers { get; set; } = [];
 
         [Display(
diff --git a/src/Microsoft.Diagnostics.Monitoring.Options/MetricsOptionsValidator.cs b/src/Microsoft.Diagnostics.Monitoring.Options/MetricsOptionsValidator.cs
new file mode 100644
index 00000000000..6ec1d27f5b0
--- /dev/null
+++ b/src/Microsoft.Diagnostics.Monitoring.Options/MetricsOptionsValidator.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    [OptionsValidator]
+    public partial class MetricsOptionsValidator : IValidateOptions<MetricsOptions>
+    {
+    }
+}
diff --git a/src/Microsoft.Diagnostics.Monitoring.Options/Microsoft.Diagnostics.Monitoring.Options.csproj b/src/Microsoft.Diagnostics.Monitoring.Options/Microsoft.Diagnostics.Monitoring.Options.csproj
index f11b2d63e0e..b8763eb1259 100644
--- a/src/Microsoft.Diagnostics.Monitoring.Options/Microsoft.Diagnostics.Monitoring.Options.csproj
+++ b/src/Microsoft.Diagnostics.Monitoring.Options/Microsoft.Diagnostics.Monitoring.Options.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <!--
@@ -9,6 +9,7 @@
     <IsShippingAssembly>true</IsShippingAssembly>
     <OutputType>Library</OutputType>
     <Nullable>enable</Nullable>
+    <DisableOptionsValidationGenerator>true</DisableOptionsValidationGenerator>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/Microsoft.Diagnostics.Monitoring.Options/Validators.cs b/src/Microsoft.Diagnostics.Monitoring.Options/Validators.cs
new file mode 100644
index 00000000000..11b6c4bbb62
--- /dev/null
+++ b/src/Microsoft.Diagnostics.Monitoring.Options/Validators.cs
@@ -0,0 +1,393 @@
+
+    // <auto-generated/>
+    #nullable enable
+    #pragma warning disable CS1591 // Compensate for https://github.com/dotnet/roslyn/issues/54103
+    namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    internal sealed partial class __MetricProviderValidator__
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public static global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Monitoring.WebApi.MetricProvider options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "MetricProvider.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "ProviderName";
+            context.DisplayName = "MetricProvider.ProviderName";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.ProviderName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    partial class GlobalCounterOptionsValidator
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Monitoring.WebApi.GlobalCounterOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "GlobalCounterOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "IntervalSeconds";
+            context.DisplayName = "GlobalCounterOptions.IntervalSeconds";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A2);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.IntervalSeconds, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "MaxHistograms";
+            context.DisplayName = "GlobalCounterOptions.MaxHistograms";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A3);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.MaxHistograms, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "MaxTimeSeries";
+            context.DisplayName = "GlobalCounterOptions.MaxTimeSeries";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A3);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.MaxTimeSeries, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = string.IsNullOrEmpty(name) ? "GlobalCounterOptions.Validate" : $"{name}.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    partial class GlobalProviderOptionsValidator
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Monitoring.WebApi.GlobalProviderOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "GlobalProviderOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "IntervalSeconds";
+            context.DisplayName = "GlobalProviderOptions.IntervalSeconds";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A2);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.IntervalSeconds, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    partial class MetricsOptionsValidator
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Monitoring.WebApi.MetricsOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "MetricsOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "MetricCount";
+            context.DisplayName = "MetricsOptions.MetricCount";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A3);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.MetricCount, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            if (options.Providers is not null)
+            {
+                var count = 0;
+                foreach (var o in options.Providers)
+                {
+                    if (o is not null)
+                    {
+                        (builder ??= new()).AddResult(global::Microsoft.Diagnostics.Monitoring.WebApi.__MetricProviderValidator__.Validate(string.IsNullOrEmpty(name) ? $"MetricsOptions.Providers[{count}]" : $"{name}.Providers[{count}]", o));
+                    }
+                    else
+                    {
+                        (builder ??= new()).AddError(string.IsNullOrEmpty(name) ? $"MetricsOptions.Providers[{count}] is null" : $"{name}.Providers[{count}] is null");
+                    }
+                    count++;
+                }
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.Egress.FileSystem
+{
+    partial class FileSystemEgressProviderOptionsValidator
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.Egress.FileSystem.FileSystemEgressProviderOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "FileSystemEgressProviderOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "DirectoryPath";
+            context.DisplayName = "FileSystemEgressProviderOptions.DirectoryPath";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.DirectoryPath, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "CopyBufferSize";
+            context.DisplayName = "FileSystemEgressProviderOptions.CopyBufferSize";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A3);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.CopyBufferSize, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace __OptionValidationStaticInstances
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    file static class __Attributes
+    {
+        internal static readonly global::System.ComponentModel.DataAnnotations.RequiredAttribute A1 = new global::System.ComponentModel.DataAnnotations.RequiredAttribute();
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute A2 = new __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute(
+            (double)1,
+            (double)86400);
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute A3 = new __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute(
+            (int)1,
+            (int)2147483647);
+    }
+}
+namespace __OptionValidationStaticInstances
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    file static class __Validators
+    {
+    }
+}
+namespace __OptionValidationGeneratedAttributes
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    [global::System.AttributeUsage(global::System.AttributeTargets.Property | global::System.AttributeTargets.Field | global::System.AttributeTargets.Parameter, AllowMultiple = false)]
+    file class __SourceGen__RangeAttribute : global::System.ComponentModel.DataAnnotations.ValidationAttribute
+    {
+        public __SourceGen__RangeAttribute(int minimum, int maximum) : base()
+        {
+            Minimum = minimum;
+            Maximum = maximum;
+            OperandType = typeof(int);
+        }
+        public __SourceGen__RangeAttribute(double minimum, double maximum) : base()
+        {
+            Minimum = minimum;
+            Maximum = maximum;
+            OperandType = typeof(double);
+        }
+        public __SourceGen__RangeAttribute(global::System.Type type, string minimum, string maximum) : base()
+        {
+            OperandType = type;
+            _needToConvertMinMax = true;
+            Minimum = minimum;
+            Maximum = maximum;
+        }
+        public object Minimum { get; private set; }
+        public object Maximum { get; private set; }
+        public bool MinimumIsExclusive { get; set; }
+        public bool MaximumIsExclusive { get; set; }
+        public global::System.Type OperandType { get; }
+        public bool ParseLimitsInInvariantCulture { get; set; }
+        public bool ConvertValueInInvariantCulture { get; set; }
+        public override string FormatErrorMessage(string name) =>
+                string.Format(global::System.Globalization.CultureInfo.CurrentCulture, GetValidationErrorMessage(), name, Minimum, Maximum);
+        private readonly bool _needToConvertMinMax;
+        private volatile bool _initialized;
+        private readonly object _lock = new();
+        private const string MinMaxError = "The minimum and maximum values must be set to valid values.";
+
+        public override bool IsValid(object? value)
+        {
+            if (!_initialized)
+            {
+                lock (_lock)
+                {
+                    if (!_initialized)
+                    {
+                        if (Minimum is null || Maximum is null)
+                        {
+                            throw new global::System.InvalidOperationException(MinMaxError);
+                        }
+                        if (_needToConvertMinMax)
+                        {
+                            System.Globalization.CultureInfo culture = ParseLimitsInInvariantCulture ? global::System.Globalization.CultureInfo.InvariantCulture : global::System.Globalization.CultureInfo.CurrentCulture;
+                            Minimum = ConvertValue(Minimum, culture) ?? throw new global::System.InvalidOperationException(MinMaxError);
+                            Maximum = ConvertValue(Maximum, culture) ?? throw new global::System.InvalidOperationException(MinMaxError);
+                        }
+                        int cmp = ((global::System.IComparable)Minimum).CompareTo((global::System.IComparable)Maximum);
+                        if (cmp > 0)
+                        {
+                            throw new global::System.InvalidOperationException("The maximum value '{Maximum}' must be greater than or equal to the minimum value '{Minimum}'.");
+                        }
+                        else if (cmp == 0 && (MinimumIsExclusive || MaximumIsExclusive))
+                        {
+                            throw new global::System.InvalidOperationException("Cannot use exclusive bounds when the maximum value is equal to the minimum value.");
+                        }
+                        _initialized = true;
+                    }
+                }
+            }
+
+            if (value is null or string { Length: 0 })
+            {
+                return true;
+            }
+
+            System.Globalization.CultureInfo formatProvider = ConvertValueInInvariantCulture ? global::System.Globalization.CultureInfo.InvariantCulture : global::System.Globalization.CultureInfo.CurrentCulture;
+            object? convertedValue;
+
+            try
+            {
+                convertedValue = ConvertValue(value, formatProvider);
+            }
+            catch (global::System.Exception e) when (e is global::System.FormatException or global::System.InvalidCastException or global::System.NotSupportedException)
+            {
+                return false;
+            }
+
+            var min = (global::System.IComparable)Minimum;
+            var max = (global::System.IComparable)Maximum;
+
+            return
+                (MinimumIsExclusive ? min.CompareTo(convertedValue) < 0 : min.CompareTo(convertedValue) <= 0) &&
+                (MaximumIsExclusive ? max.CompareTo(convertedValue) > 0 : max.CompareTo(convertedValue) >= 0);
+        }
+        private string GetValidationErrorMessage()
+        {
+            return (MinimumIsExclusive, MaximumIsExclusive) switch
+            {
+                (false, false) => "The field {0} must be between {1} and {2}.",
+                (true, false) => "The field {0} must be between {1} exclusive and {2}.",
+                (false, true) => "The field {0} must be between {1} and {2} exclusive.",
+                (true, true) => "The field {0} must be between {1} exclusive and {2} exclusive.",
+            };
+        }
+        private object? ConvertValue(object? value, System.Globalization.CultureInfo formatProvider)
+        {
+            if (value is string stringValue)
+            {
+                value = global::System.Convert.ChangeType(stringValue, OperandType, formatProvider);
+            }
+            else
+            {
+                value = global::System.Convert.ChangeType(value, OperandType, formatProvider);
+            }
+            return value;
+        }
+    }
+}
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTestCommon/CollectionRules/Actions/CallbackAction.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTestCommon/CollectionRules/Actions/CallbackAction.cs
index 4e2c28bfc82..579c8d51d3e 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTestCommon/CollectionRules/Actions/CallbackAction.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTestCommon/CollectionRules/Actions/CallbackAction.cs
@@ -6,6 +6,7 @@
 using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Configuration;
 using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.Threading;
@@ -75,17 +76,19 @@ public ICollectionRuleAction Create(IProcessInfo processInfo, BaseRecordOptions
         }
     }
 
-    internal sealed class CallbackActionDescriptor : ICollectionRuleActionDescriptor
+    internal sealed partial class CallbackActionDescriptor : ICollectionRuleActionDescriptor<BaseRecordOptions, CallbackActionFactory>
     {
         public string ActionName => CallbackAction.ActionName;
-        public Type OptionsType => typeof(BaseRecordOptions);
-        public Type FactoryType => typeof(CallbackActionFactory);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out BaseRecordOptions options)
         {
-            BaseRecordOptions options = new();
+            options = new();
             settingsSection.Bind(options);
-            settings = options;
+        }
+
+        public ValidateOptionsResult Validate(string name, BaseRecordOptions options)
+        {
+            return ValidateOptionsResult.Success;
         }
     }
 
@@ -127,17 +130,19 @@ public Task<CollectionRuleActionResult> WaitForCompletionAsync(CancellationToken
         }
     }
 
-    internal sealed class DelayedCallbackActionDescriptor : ICollectionRuleActionDescriptor
+    internal sealed partial class DelayedCallbackActionDescriptor : ICollectionRuleActionDescriptor<BaseRecordOptions, DelayedCallbackActionFactory>
     {
         public string ActionName => DelayedCallbackAction.ActionName;
-        public Type OptionsType => typeof(BaseRecordOptions);
-        public Type FactoryType => typeof(DelayedCallbackActionFactory);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out BaseRecordOptions options)
         {
-            BaseRecordOptions options = new();
+            options = new();
             settingsSection.Bind(options);
-            settings = options;
+        }
+
+        public ValidateOptionsResult Validate(string name, BaseRecordOptions options)
+        {
+            return ValidateOptionsResult.Success;
         }
     }
 
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTestCommon/CollectionRules/Actions/PassThroughAction.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTestCommon/CollectionRules/Actions/PassThroughAction.cs
index f8b350b6bda..58fdccd522e 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTestCommon/CollectionRules/Actions/PassThroughAction.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTestCommon/CollectionRules/Actions/PassThroughAction.cs
@@ -6,7 +6,7 @@
 using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Configuration;
 using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions;
 using Microsoft.Extensions.Configuration;
-using System;
+using Microsoft.Extensions.Options;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -56,17 +56,19 @@ public Task<CollectionRuleActionResult> WaitForCompletionAsync(CancellationToken
         }
     }
 
-    internal sealed class PassThroughActionDescriptor : ICollectionRuleActionDescriptor
+    internal sealed partial class PassThroughActionDescriptor : ICollectionRuleActionDescriptor<PassThroughOptions, PassThroughActionFactory>
     {
         public string ActionName => nameof(PassThroughAction);
-        public Type OptionsType => typeof(PassThroughOptions);
-        public Type FactoryType => typeof(PassThroughActionFactory);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out PassThroughOptions options)
         {
-            PassThroughOptions options = new();
+            options = new();
             settingsSection.Bind(options);
-            settings = options;
+        }
+
+        public ValidateOptionsResult Validate(string name, PassThroughOptions options)
+        {
+            return ValidateOptionsResult.Success;
         }
     }
 
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRuleDefaultsTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRuleDefaultsTests.cs
index 7ffb6ee6611..082c543a608 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRuleDefaultsTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRuleDefaultsTests.cs
@@ -70,9 +70,11 @@ await TestHostHelper.CreateCollectionRulesHost(_outputHelper, rootOptions =>
             }, host =>
             {
                 OptionsValidationException invalidOptionsException = Assert.Throws<OptionsValidationException>(
-                        () => ActionTestsHelper.GetActionOptions<OptionsValidationException>(host, DefaultRuleName));
+                        () => ActionTestsHelper.GetActionOptions<CollectDumpOptions>(host, DefaultRuleName));
 
-                Assert.Equal(string.Format(OptionsDisplayStrings.ErrorMessage_NoDefaultEgressProvider), invalidOptionsException.Message);
+                string message = string.Format(OptionsDisplayStrings.ErrorMessage_NoDefaultEgressProvider);
+
+                Assert.Equal($"{nameof(CollectDumpOptions.Egress)}: {message}", invalidOptionsException.Message);
             });
         }
 
@@ -143,7 +145,7 @@ await TestHostHelper.CreateCollectionRulesHost(_outputHelper, rootOptions =>
                 OptionsValidationException invalidOptionsException = Assert.Throws<OptionsValidationException>(
                         () => TriggerTestsHelper.GetTriggerOptions<AspNetRequestCountOptions>(host, DefaultRuleName));
 
-                VerifyRangeMessage<int>(invalidOptionsException, nameof(AspNetRequestCountOptions.RequestCount), "1", int.MaxValue.ToString());
+                VerifyRangeMessage<int>(invalidOptionsException, nameof(AspNetRequestCountOptions), nameof(AspNetRequestCountOptions.RequestCount), "1", int.MaxValue.ToString());
             });
         }
 
@@ -217,7 +219,7 @@ await TestHostHelper.CreateCollectionRulesHost(_outputHelper, rootOptions =>
                 OptionsValidationException invalidOptionsException = Assert.Throws<OptionsValidationException>(
                         () => TriggerTestsHelper.GetTriggerOptions<AspNetRequestDurationOptions>(host, DefaultRuleName));
 
-                VerifyRangeMessage<int>(invalidOptionsException, nameof(AspNetRequestDurationOptions.RequestCount), "1", int.MaxValue.ToString());
+                VerifyRangeMessage<int>(invalidOptionsException, nameof(AspNetRequestDurationOptions), nameof(AspNetRequestDurationOptions.RequestCount), "1", int.MaxValue.ToString());
             });
         }
 
@@ -297,7 +299,7 @@ await TestHostHelper.CreateCollectionRulesHost(_outputHelper, rootOptions =>
                 OptionsValidationException invalidOptionsException = Assert.Throws<OptionsValidationException>(
                         () => TriggerTestsHelper.GetTriggerOptions<AspNetResponseStatusOptions>(host, DefaultRuleName));
 
-                VerifyRangeMessage<int>(invalidOptionsException, nameof(AspNetResponseStatusOptions.ResponseCount), "1", int.MaxValue.ToString());
+                VerifyRangeMessage<int>(invalidOptionsException, nameof(AspNetResponseStatusOptions), nameof(AspNetResponseStatusOptions.ResponseCount), "1", int.MaxValue.ToString());
             });
         }
 
@@ -550,11 +552,11 @@ await TestHostHelper.CreateCollectionRulesHost(_outputHelper, rootOptions =>
             });
         }
 
-        private static void VerifyRangeMessage<T>(Exception ex, string fieldName, string min, string max)
+        private static void VerifyRangeMessage<T>(Exception ex, string typeName, string fieldName, string min, string max)
         {
-            string message = (new RangeAttribute(typeof(T), min, max)).FormatErrorMessage(fieldName);
+            string message = (new RangeAttribute(typeof(T), min, max)).FormatErrorMessage($"{typeName}.{fieldName}");
 
-            Assert.Equal(message, ex.Message);
+            Assert.Equal($"{fieldName}: {message}", ex.Message);
         }
     }
 }
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRuleOptionsTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRuleOptionsTests.cs
index 31cbb996d67..0621b864c40 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRuleOptionsTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRuleOptionsTests.cs
@@ -77,7 +77,7 @@ public Task CollectionRuleOptions_NoTrigger()
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(CollectionRuleOptions.Trigger));
+                    VerifyRequiredMessage(failures, 0, nameof(CollectionRuleOptions), nameof(CollectionRuleOptions.Trigger));
                 });
         }
 
@@ -195,14 +195,12 @@ public Task CollectionRuleOptions_EventCounterTrigger_PropertyValidation()
                 ex =>
                 {
                     string[] failures = ex.Failures.ToArray();
-                    // Property validation failures will short-circuit the remainder of the validation
-                    // rules, thus only observe 3 errors when one might expect 4 (the fourth being that
-                    // either GreaterThan or LessThan should be specified).
-                    Assert.Equal(3, failures.Length);
-                    VerifyRequiredMessage(failures, 0, nameof(EventCounterOptions.ProviderName));
-                    VerifyRequiredMessage(failures, 1, nameof(EventCounterOptions.CounterName));
-                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(EventCounterOptions.SlidingWindowDuration),
+                    Assert.Equal(4, failures.Length);
+                    VerifyRequiredMessage(failures, 0, nameof(EventCounterOptions), nameof(EventCounterOptions.ProviderName));
+                    VerifyRequiredMessage(failures, 1, nameof(EventCounterOptions), nameof(EventCounterOptions.CounterName));
+                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(EventCounterOptions), nameof(EventCounterOptions.SlidingWindowDuration),
                         TriggerOptionsConstants.SlidingWindowDuration_MinValue, TriggerOptionsConstants.SlidingWindowDuration_MaxValue);
+                    VerifyEitherRequiredMessage(failures, 3, nameof(EventCounterOptions.GreaterThan), nameof(EventCounterOptions.LessThan));
                 });
         }
 
@@ -362,13 +360,12 @@ public Task CollectionRuleOptions_EventMeterTrigger_PropertyValidation()
                 ex =>
                 {
                     string[] failures = ex.Failures.ToArray();
-                    // Property validation failures will short-circuit the remainder of the validation
-                    // rules, thus only observe 3 errors when one might expect 4 (GreaterThan or LessThan should be specified).
-                    Assert.Equal(3, failures.Length);
-                    VerifyRequiredMessage(failures, 0, nameof(EventMeterOptions.MeterName));
-                    VerifyRequiredMessage(failures, 1, nameof(EventMeterOptions.InstrumentName));
-                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(EventMeterOptions.SlidingWindowDuration),
+                    Assert.Equal(4, failures.Length);
+                    VerifyRequiredMessage(failures, 0, nameof(EventMeterOptions), nameof(EventMeterOptions.MeterName));
+                    VerifyRequiredMessage(failures, 1, nameof(EventMeterOptions), nameof(EventMeterOptions.InstrumentName));
+                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(EventMeterOptions), nameof(EventMeterOptions.SlidingWindowDuration),
                         TriggerOptionsConstants.SlidingWindowDuration_MinValue, TriggerOptionsConstants.SlidingWindowDuration_MaxValue);
+                    VerifyEitherRequiredMessage(failures, 3, nameof(EventMeterOptions.GreaterThan), nameof(EventMeterOptions.LessThan));
                 });
         }
 
@@ -410,8 +407,8 @@ public Task CollectionRuleOptions_EventMeterTrigger_NoInstrumentOrMeterName()
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Equal(2, failures.Length);
-                    VerifyRequiredMessage(failures, 0, nameof(EventMeterOptions.MeterName));
-                    VerifyRequiredMessage(failures, 1, nameof(EventMeterOptions.InstrumentName));
+                    VerifyRequiredMessage(failures, 0, nameof(EventMeterOptions), nameof(EventMeterOptions.MeterName));
+                    VerifyRequiredMessage(failures, 1, nameof(EventMeterOptions), nameof(EventMeterOptions.InstrumentName));
                 });
         }
 
@@ -460,7 +457,7 @@ public Task CollectionRuleOptions_EventMeterTrigger_InvalidHistogramPercentile(i
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
 
-                    VerifyRangeMessage<int>(failures, 0, nameof(EventMeterOptions.HistogramPercentile),
+                    VerifyRangeMessage<int>(failures, 0, nameof(EventMeterOptions), nameof(EventMeterOptions.HistogramPercentile),
                         TriggerOptionsConstants.Percentage_MinValue.ToString(), TriggerOptionsConstants.Percentage_MaxValue.ToString());
                 });
         }
@@ -550,11 +547,11 @@ public Task CollectionRuleOptions_CPUUsageTrigger_PropertyValidation()
                     string[] failures = ex.Failures.ToArray();
 
                     Assert.Equal(3, failures.Length);
-                    VerifyRangeMessage<double>(failures, 0, nameof(CPUUsageOptions.GreaterThan),
+                    VerifyRangeMessage<double>(failures, 0, nameof(CPUUsageOptions), nameof(CPUUsageOptions.GreaterThan),
                         TriggerOptionsConstants.Percentage_MinValue.ToString(), TriggerOptionsConstants.Percentage_MaxValue.ToString());
-                    VerifyRangeMessage<double>(failures, 1, nameof(CPUUsageOptions.LessThan),
+                    VerifyRangeMessage<double>(failures, 1, nameof(CPUUsageOptions), nameof(CPUUsageOptions.LessThan),
                         TriggerOptionsConstants.Percentage_MinValue.ToString(), TriggerOptionsConstants.Percentage_MaxValue.ToString());
-                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(CPUUsageOptions.SlidingWindowDuration),
+                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(CPUUsageOptions), nameof(CPUUsageOptions.SlidingWindowDuration),
                         TriggerOptionsConstants.SlidingWindowDuration_MinValue, TriggerOptionsConstants.SlidingWindowDuration_MaxValue);
                 });
         }
@@ -578,11 +575,11 @@ public Task CollectionRuleOptions_GCHeapSizeTrigger_PropertyValidation()
                     string[] failures = ex.Failures.ToArray();
 
                     Assert.Equal(3, failures.Length);
-                    VerifyRangeMessage<double>(failures, 0, nameof(GCHeapSizeOptions.GreaterThan),
+                    VerifyRangeMessage<double>(failures, 0, nameof(GCHeapSizeOptions), nameof(GCHeapSizeOptions.GreaterThan),
                         "0", double.MaxValue.ToString());
-                    VerifyRangeMessage<double>(failures, 1, nameof(GCHeapSizeOptions.LessThan),
+                    VerifyRangeMessage<double>(failures, 1, nameof(GCHeapSizeOptions), nameof(GCHeapSizeOptions.LessThan),
                         "0", double.MaxValue.ToString());
-                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(GCHeapSizeOptions.SlidingWindowDuration),
+                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(GCHeapSizeOptions), nameof(GCHeapSizeOptions.SlidingWindowDuration),
                         TriggerOptionsConstants.SlidingWindowDuration_MinValue, TriggerOptionsConstants.SlidingWindowDuration_MaxValue);
                 });
         }
@@ -606,11 +603,11 @@ public Task CollectionRuleOptions_ThreadpoolQueueLengthTrigger_PropertyValidatio
                     string[] failures = ex.Failures.ToArray();
 
                     Assert.Equal(3, failures.Length);
-                    VerifyRangeMessage<double>(failures, 0, nameof(ThreadpoolQueueLengthOptions.GreaterThan),
+                    VerifyRangeMessage<double>(failures, 0, nameof(ThreadpoolQueueLengthOptions), nameof(ThreadpoolQueueLengthOptions.GreaterThan),
                         "0", double.MaxValue.ToString());
-                    VerifyRangeMessage<double>(failures, 1, nameof(ThreadpoolQueueLengthOptions.LessThan),
+                    VerifyRangeMessage<double>(failures, 1, nameof(ThreadpoolQueueLengthOptions), nameof(ThreadpoolQueueLengthOptions.LessThan),
                         "0", double.MaxValue.ToString());
-                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(ThreadpoolQueueLengthOptions.SlidingWindowDuration),
+                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(ThreadpoolQueueLengthOptions), nameof(ThreadpoolQueueLengthOptions.SlidingWindowDuration),
                         TriggerOptionsConstants.SlidingWindowDuration_MinValue, TriggerOptionsConstants.SlidingWindowDuration_MaxValue);
                 });
         }
@@ -703,7 +700,7 @@ public Task CollectionRuleOptions_AspNetRequestCountTrigger_RequiredPropertyVali
                     string[] failures = ex.Failures.ToArray();
 
                     Assert.Single(failures);
-                    VerifyRangeMessage<int>(failures, 0, nameof(AspNetRequestCountOptions.RequestCount), "1", int.MaxValue.ToString()); // Since non-nullable, defaults to 0
+                    VerifyRangeMessage<int>(failures, 0, nameof(AspNetRequestCountOptions), nameof(AspNetRequestCountOptions.RequestCount), "1", int.MaxValue.ToString()); // Since non-nullable, defaults to 0
                 });
         }
 
@@ -725,8 +722,8 @@ public Task CollectionRuleOptions_AspNetRequestCountTrigger_RangePropertyValidat
                     string[] failures = ex.Failures.ToArray();
 
                     Assert.Equal(2, failures.Length);
-                    VerifyRangeMessage<int>(failures, 0, nameof(AspNetRequestCountOptions.RequestCount), "1", int.MaxValue.ToString());
-                    VerifyRangeMessage<TimeSpan>(failures, 1, nameof(AspNetRequestCountOptions.SlidingWindowDuration),
+                    VerifyRangeMessage<int>(failures, 0, nameof(AspNetRequestCountOptions), nameof(AspNetRequestCountOptions.RequestCount), "1", int.MaxValue.ToString());
+                    VerifyRangeMessage<TimeSpan>(failures, 1, nameof(AspNetRequestCountOptions), nameof(AspNetRequestCountOptions.SlidingWindowDuration),
                         TriggerOptionsConstants.SlidingWindowDuration_MinValue, TriggerOptionsConstants.SlidingWindowDuration_MaxValue);
                 });
         }
@@ -799,7 +796,7 @@ public Task CollectionRuleOptions_AspNetRequestDurationTrigger_RequiredPropertyV
                     string[] failures = ex.Failures.ToArray();
 
                     Assert.Single(failures);
-                    VerifyRangeMessage<int>(failures, 0, nameof(AspNetRequestDurationOptions.RequestCount), "1", int.MaxValue.ToString()); // Since non-nullable, defaults to 0
+                    VerifyRangeMessage<int>(failures, 0, nameof(AspNetRequestDurationOptions), nameof(AspNetRequestDurationOptions.RequestCount), "1", int.MaxValue.ToString()); // Since non-nullable, defaults to 0
                 });
         }
 
@@ -822,10 +819,10 @@ public Task CollectionRuleOptions_AspNetRequestDurationTrigger_RangePropertyVali
                     string[] failures = ex.Failures.ToArray();
 
                     Assert.Equal(3, failures.Length);
-                    VerifyRangeMessage<int>(failures, 0, nameof(AspNetRequestDurationOptions.RequestCount), "1", int.MaxValue.ToString());
-                    VerifyRangeMessage<TimeSpan>(failures, 1, nameof(AspNetRequestDurationOptions.RequestDuration),
+                    VerifyRangeMessage<int>(failures, 0, nameof(AspNetRequestDurationOptions), nameof(AspNetRequestDurationOptions.RequestCount), "1", int.MaxValue.ToString());
+                    VerifyRangeMessage<TimeSpan>(failures, 1, nameof(AspNetRequestDurationOptions), nameof(AspNetRequestDurationOptions.RequestDuration),
                         AspNetRequestDurationOptions.RequestDuration_MinValue, AspNetRequestDurationOptions.RequestDuration_MaxValue);
-                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(AspNetRequestDurationOptions.SlidingWindowDuration),
+                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(AspNetRequestDurationOptions), nameof(AspNetRequestDurationOptions.SlidingWindowDuration),
                         TriggerOptionsConstants.SlidingWindowDuration_MinValue, TriggerOptionsConstants.SlidingWindowDuration_MaxValue);
                 });
         }
@@ -901,8 +898,8 @@ public Task CollectionRuleOptions_AspNetResponseStatusTrigger_RequiredPropertyVa
                     string[] failures = ex.Failures.ToArray();
 
                     Assert.Equal(2, failures.Length);
-                    VerifyRequiredMessage(failures, 0, nameof(AspNetResponseStatusOptions.StatusCodes));
-                    VerifyRangeMessage<int>(failures, 1, nameof(AspNetResponseStatusOptions.ResponseCount), "1", int.MaxValue.ToString()); // Since non-nullable, defaults to 0
+                    VerifyRequiredMessage(failures, 0, nameof(AspNetResponseStatusOptions), nameof(AspNetResponseStatusOptions.StatusCodes));
+                    VerifyRangeMessage<int>(failures, 1, nameof(AspNetResponseStatusOptions), nameof(AspNetResponseStatusOptions.ResponseCount), "1", int.MaxValue.ToString()); // Since non-nullable, defaults to 0
                 });
         }
 
@@ -927,9 +924,9 @@ public Task CollectionRuleOptions_AspNetResponseStatusTrigger_RangePropertyValid
                     string[] failures = ex.Failures.ToArray();
 
                     Assert.Equal(3, failures.Length);
-                    VerifyStatusCodesRegexMessage(failures, 0, nameof(AspNetResponseStatusOptions.StatusCodes));
-                    VerifyRangeMessage<int>(failures, 1, nameof(AspNetResponseStatusOptions.ResponseCount), "1", int.MaxValue.ToString());
-                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(AspNetResponseStatusOptions.SlidingWindowDuration),
+                    VerifyStatusCodesRegexMessage(failures, 0, nameof(AspNetResponseStatusOptions), nameof(AspNetResponseStatusOptions.StatusCodes));
+                    VerifyRangeMessage<int>(failures, 1, nameof(AspNetResponseStatusOptions), nameof(AspNetResponseStatusOptions.ResponseCount), "1", int.MaxValue.ToString());
+                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(AspNetResponseStatusOptions), nameof(AspNetResponseStatusOptions.SlidingWindowDuration),
                         TriggerOptionsConstants.SlidingWindowDuration_MinValue, TriggerOptionsConstants.SlidingWindowDuration_MaxValue);
                 });
         }
@@ -968,7 +965,7 @@ public Task CollectionRuleOptions_CollectDumpAction_PropertyValidation()
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Equal(2, failures.Length);
-                    VerifyEnumDataTypeMessage<DumpType>(failures, 0, nameof(CollectDumpOptions.Type));
+                    VerifyEnumDataTypeMessage<DumpType>(failures, 0, nameof(CollectDumpOptions), nameof(CollectDumpOptions.Type));
                     VerifyEgressNotExistMessage(failures, 1, UnknownEgressName);
                 });
         }
@@ -1091,10 +1088,10 @@ public Task CollectionRuleOptions_CollectLogsAction_PropertyValidation()
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Equal(3, failures.Length);
-                    VerifyEnumDataTypeMessage<LogLevel>(failures, 0, nameof(CollectLogsOptions.DefaultLevel));
-                    VerifyRangeMessage<TimeSpan>(failures, 1, nameof(CollectLogsOptions.Duration),
+                    VerifyEnumDataTypeMessage<LogLevel>(failures, 0, nameof(CollectLogsOptions), nameof(CollectLogsOptions.DefaultLevel));
+                    VerifyRangeMessage<TimeSpan>(failures, 1, nameof(CollectLogsOptions), nameof(CollectLogsOptions.Duration),
                         ActionOptionsConstants.Duration_MinValue, ActionOptionsConstants.Duration_MaxValue);
-                    VerifyRequiredOrDefaultEgressProvider(failures, 2);
+                    VerifyRequiredOrDefaultEgressProvider(failures, 2, nameof(CollectLogsOptions.Egress));
                 });
         }
 
@@ -1122,7 +1119,7 @@ public Task CollectionRuleOptions_CollectLogsAction_FilterSpecValidation()
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyEnumDataTypeMessage<LogLevel>(failures, 0, nameof(CollectLogsOptions.FilterSpecs));
+                    VerifyEnumDataTypeMessage<LogLevel>(failures, 0, nameof(CollectLogsOptions), nameof(CollectLogsOptions.FilterSpecs));
                 });
         }
 
@@ -1259,12 +1256,12 @@ public Task CollectionRuleOptions_CollectTraceAction_PropertyValidation()
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Equal(4, failures.Length);
-                    VerifyEnumDataTypeMessage<TraceProfile>(failures, 0, nameof(CollectTraceOptions.Profile));
-                    VerifyRangeMessage<int>(failures, 1, nameof(CollectTraceOptions.BufferSizeMegabytes),
+                    VerifyEnumDataTypeMessage<TraceProfile>(failures, 0, nameof(CollectTraceOptions), nameof(CollectTraceOptions.Profile));
+                    VerifyRangeMessage<int>(failures, 1, nameof(CollectTraceOptions), nameof(CollectTraceOptions.BufferSizeMegabytes),
                         ActionOptionsConstants.BufferSizeMegabytes_MinValue_String, ActionOptionsConstants.BufferSizeMegabytes_MaxValue_String);
-                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(CollectTraceOptions.Duration),
+                    VerifyRangeMessage<TimeSpan>(failures, 2, nameof(CollectTraceOptions), nameof(CollectTraceOptions.Duration),
                         ActionOptionsConstants.Duration_MinValue, ActionOptionsConstants.Duration_MaxValue);
-                    VerifyRequiredOrDefaultEgressProvider(failures, 3);
+                    VerifyRequiredOrDefaultEgressProvider(failures, 3, nameof(CollectTraceOptions.Egress));
                 });
         }
 
@@ -1294,7 +1291,7 @@ public Task CollectionRuleOptions_CollectTraceAction_ValidateProviderIntervals()
                 ex =>
                 {
                     string failure = Assert.Single(ex.Failures);
-                    VerifyProviderIntervalMessage(failure, MonitoringSourceConfiguration.SystemRuntimeEventSourceName, ExpectedInterval);
+                    VerifyProviderIntervalMessage(failure, nameof(EventPipeProvider.Arguments), MonitoringSourceConfiguration.SystemRuntimeEventSourceName, ExpectedInterval);
                 });
         }
 
@@ -1401,7 +1398,7 @@ public Task CollectionRuleOptions_CollectTraceAction_ProviderPropertyValidation(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(EventPipeProvider.Name));
+                    VerifyRequiredMessage(failures, 0, nameof(EventPipeProvider), nameof(EventPipeProvider.Name));
                 });
         }
 
@@ -1586,7 +1583,7 @@ public Task CollectionRuleOptions_CollectLiveMetricsAction_PropertyValidation()
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Equal(2, failures.Length);
-                    VerifyRangeMessage<TimeSpan>(failures, 0, nameof(CollectTraceOptions.Duration),
+                    VerifyRangeMessage<TimeSpan>(failures, 0, nameof(CollectLiveMetricsOptions), nameof(CollectLiveMetricsOptions.Duration),
                         ActionOptionsConstants.Duration_MinValue, ActionOptionsConstants.Duration_MaxValue);
                     VerifyEgressNotExistMessage(failures, 1, UnknownEgressName);
                 });
@@ -1645,7 +1642,7 @@ public Task CollectionRuleOptions_ExecuteAction_PropertyValidation()
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(ExecuteOptions.Path));
+                    VerifyRequiredMessage(failures, 0, nameof(ExecuteOptions), nameof(ExecuteOptions.Path));
                 });
         }
 
@@ -1694,7 +1691,7 @@ await ValidateFailure(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(LoadProfilerOptions.Path));
+                    VerifyRequiredMessage(failures, 0, nameof(LoadProfilerOptions), nameof(LoadProfilerOptions.Path));
                 });
 
             await ValidateFailure(
@@ -1713,7 +1710,7 @@ await ValidateFailure(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(LoadProfilerOptions.Path));
+                    VerifyRequiredMessage(failures, 0, nameof(LoadProfilerOptions), nameof(LoadProfilerOptions.Path));
                 });
 
             await ValidateFailure(
@@ -1732,7 +1729,7 @@ await ValidateFailure(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(LoadProfilerOptions.Path));
+                    VerifyRequiredMessage(failures, 0, nameof(LoadProfilerOptions), nameof(LoadProfilerOptions.Path));
                 });
         }
 
@@ -1756,7 +1753,7 @@ public Task CollectionRuleOptions_LoadProfilerAction_ClsidPropertyValidation()
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredGuidMessage(failures, 0, nameof(LoadProfilerOptions.Clsid));
+                    VerifyRequiredGuidMessage(failures, 0, nameof(LoadProfilerOptions), nameof(LoadProfilerOptions.Clsid));
                 });
         }
 
@@ -1813,7 +1810,7 @@ await ValidateFailure(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(SetEnvironmentVariableOptions.Name));
+                    VerifyRequiredMessage(failures, 0, nameof(SetEnvironmentVariableOptions), nameof(SetEnvironmentVariableOptions.Name));
                 });
 
             await ValidateFailure(
@@ -1827,7 +1824,7 @@ await ValidateFailure(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(SetEnvironmentVariableOptions.Name));
+                    VerifyRequiredMessage(failures, 0, nameof(SetEnvironmentVariableOptions), nameof(SetEnvironmentVariableOptions.Name));
                 });
 
             await ValidateFailure(
@@ -1841,7 +1838,7 @@ await ValidateFailure(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(SetEnvironmentVariableOptions.Name));
+                    VerifyRequiredMessage(failures, 0, nameof(SetEnvironmentVariableOptions), nameof(SetEnvironmentVariableOptions.Name));
                 });
         }
 
@@ -1878,7 +1875,7 @@ await ValidateFailure(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(GetEnvironmentVariableOptions.Name));
+                    VerifyRequiredMessage(failures, 0, nameof(GetEnvironmentVariableOptions), nameof(GetEnvironmentVariableOptions.Name));
                 });
 
             await ValidateFailure(
@@ -1892,7 +1889,7 @@ await ValidateFailure(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(GetEnvironmentVariableOptions.Name));
+                    VerifyRequiredMessage(failures, 0, nameof(GetEnvironmentVariableOptions), nameof(GetEnvironmentVariableOptions.Name));
                 });
 
             await ValidateFailure(
@@ -1906,7 +1903,7 @@ await ValidateFailure(
                 {
                     string[] failures = ex.Failures.ToArray();
                     Assert.Single(failures);
-                    VerifyRequiredMessage(failures, 0, nameof(GetEnvironmentVariableOptions.Name));
+                    VerifyRequiredMessage(failures, 0, nameof(GetEnvironmentVariableOptions), nameof(GetEnvironmentVariableOptions.Name));
                 });
         }
 
@@ -2261,37 +2258,39 @@ private static void VerifyUnknownTriggerTypeMessage(string[] failures, int index
             Assert.Equal(message, failures[index]);
         }
 
-        private static void VerifyRequiredMessage(string[] failures, int index, string fieldName)
+        private static void VerifyRequiredMessage(string[] failures, int index, string typeName, string fieldName)
         {
-            string message = (new RequiredAttribute()).FormatErrorMessage(fieldName);
+            string message = (new RequiredAttribute()).FormatErrorMessage($"{typeName}.{fieldName}");
 
-            Assert.Equal(message, failures[index]);
+            Assert.Equal($"{fieldName}: {message}", failures[index]);
         }
 
-        private static void VerifyRequiredOrDefaultEgressProvider(string[] failures, int index)
+        private static void VerifyRequiredOrDefaultEgressProvider(string[] failures, int index, string fieldName)
         {
-            Assert.Equal(WebApi.OptionsDisplayStrings.ErrorMessage_NoDefaultEgressProvider, failures[index]);
+            string message = WebApi.OptionsDisplayStrings.ErrorMessage_NoDefaultEgressProvider;
+
+            Assert.Equal($"{fieldName}: {message}", failures[index]);
         }
 
-        private static void VerifyRequiredGuidMessage(string[] failures, int index, string fieldName)
+        private static void VerifyRequiredGuidMessage(string[] failures, int index, string typeName, string fieldName)
         {
-            string message = (new RequiredGuidAttribute()).FormatErrorMessage(fieldName);
+            string message = (new RequiredGuidAttribute()).FormatErrorMessage($"{typeName}.{fieldName}");
 
             Assert.Equal(message, failures[index]);
         }
 
-        private static void VerifyEnumDataTypeMessage<T>(string[] failures, int index, string fieldName)
+        private static void VerifyEnumDataTypeMessage<T>(string[] failures, int index, string typeName, string fieldName)
         {
-            string message = (new EnumDataTypeAttribute(typeof(T))).FormatErrorMessage(fieldName);
+            string message = (new EnumDataTypeAttribute(typeof(T))).FormatErrorMessage($"{typeName}.{fieldName}");
 
-            Assert.Equal(message, failures[index]);
+            Assert.Equal($"{fieldName}: {message}", failures[index]);
         }
 
-        private static void VerifyRangeMessage<T>(string[] failures, int index, string fieldName, string min, string max)
+        private static void VerifyRangeMessage<T>(string[] failures, int index, string typeName, string fieldName, string min, string max)
         {
-            string message = (new RangeAttribute(typeof(T), min, max)).FormatErrorMessage(fieldName);
+            string message = (new RangeAttribute(typeof(T), min, max)).FormatErrorMessage($"{typeName}.{fieldName}");
 
-            Assert.Equal(message, failures[index]);
+            Assert.Equal($"{fieldName}: {message}", failures[index]);
         }
 
         private static void VerifyEitherRequiredMessage(string[] failures, int index, string fieldName1, string fieldName2)
@@ -2305,14 +2304,14 @@ private static void VerifyEitherRequiredMessage(string[] failures, int index, st
             Assert.Equal(message, failures[index]);
         }
 
-        private static void VerifyStatusCodesRegexMessage(string[] failures, int index, string fieldName)
+        private static void VerifyStatusCodesRegexMessage(string[] failures, int index, string typeName, string fieldName)
         {
             string message = string.Format(
                 CultureInfo.InvariantCulture,
                 WebApi.OptionsDisplayStrings.ErrorMessage_StatusCodesRegularExpressionDoesNotMatch,
-                fieldName);
+                $"{typeName}.{fieldName}");
 
-            Assert.Equal(message, failures[index]);
+            Assert.Equal($"{fieldName}: {message}", failures[index]);
         }
 
         private static void VerifyBothCannotBeSpecifiedMessage(string[] failures, int index, string fieldName1, string fieldName2)
@@ -2369,11 +2368,11 @@ private static void VerifyMissingStoppingEventProviderMessage(string[] failures,
             Assert.Equal(message, failures[index]);
         }
 
-        private static void VerifyProviderIntervalMessage(string failure, string provider, int expectedInterval)
+        private static void VerifyProviderIntervalMessage(string failure, string fieldName, string provider, int expectedInterval)
         {
             string message = string.Format(CultureInfo.CurrentCulture, WebApi.Strings.ErrorMessage_InvalidMetricInterval, provider, expectedInterval);
 
-            Assert.Equal(message, failure);
+            Assert.Equal($"{fieldName}: {message}", failure);
         }
 
         private static void VerifyNestedGlobalInterval(string failure, string provider)
@@ -2381,9 +2380,9 @@ private static void VerifyNestedGlobalInterval(string failure, string provider)
             string rangeValidationMessage = typeof(WebApi.GlobalProviderOptions)
                 .GetProperty(nameof(WebApi.GlobalProviderOptions.IntervalSeconds))
                 .GetCustomAttribute<RangeAttribute>()
-                .FormatErrorMessage(nameof(WebApi.GlobalProviderOptions.IntervalSeconds));
+                .FormatErrorMessage($"{nameof(WebApi.GlobalProviderOptions)}.{nameof(WebApi.GlobalProviderOptions.IntervalSeconds)}");
 
-            string message = string.Format(CultureInfo.CurrentCulture, WebApi.OptionsDisplayStrings.ErrorMessage_NestedProviderValidationError, provider, rangeValidationMessage);
+            string message = string.Format(CultureInfo.CurrentCulture, WebApi.OptionsDisplayStrings.ErrorMessage_NestedProviderValidationError, provider, $"{nameof(WebApi.GlobalProviderOptions.IntervalSeconds)}: {rangeValidationMessage}");
             Assert.Equal(message, failure);
         }
     }
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRulePipelineTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRulePipelineTests.cs
index 75ca11aca3d..a3889d34d03 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRulePipelineTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/CollectionRulePipelineTests.cs
@@ -473,8 +473,8 @@ public Task CollectionRulePipeline_ActionCountLimitSlidingDurationTest(TargetFra
         {
             const int IterationCount = 5;
             const int ExpectedActionExecutionCount = 3;
-            TimeSpan SlidingWindowDuration = TimeSpan.FromMilliseconds(100);
-            TimeSpan ClockIncrementDuration = TimeSpan.FromMilliseconds(10);
+            TimeSpan SlidingWindowDuration = TimeSpan.FromMilliseconds(1000);
+            TimeSpan ClockIncrementDuration = TimeSpan.FromMilliseconds(100);
 
             MockTimeProvider timeProvider = new();
             ManualTriggerService triggerService = new();
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/FileSystemEgressExtensionTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/FileSystemEgressExtensionTests.cs
index 9a9ba33bf8b..4e12d708f58 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/FileSystemEgressExtensionTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/FileSystemEgressExtensionTests.cs
@@ -30,6 +30,7 @@ public sealed class FileSystemEgressExtensionTests
         const string ExpectedFileContent = "This is egressed data.";
 
         private static readonly string CopyBufferSize_RangeErrorMessage = CreateRangeMessage<int>(
+            nameof(FileSystemEgressProviderOptions),
             nameof(FileSystemEgressProviderOptions.CopyBufferSize),
             FileSystemEgressProviderOptions.CopyBufferSize_MinValue.ToString(),
             FileSystemEgressProviderOptions.CopyBufferSize_MaxValue.ToString());
@@ -51,7 +52,8 @@ public async Task FileSystemEgressExtension_EmptyConfiguration_ThrowsException()
             OptionsValidationException exception = await Assert.ThrowsAsync<OptionsValidationException>(
                 () => extension.EgressArtifact(ProviderName, CreateSettings(), WriteFileContent, CancellationToken.None));
             string errorMessage = Assert.Single(exception.Failures);
-            Assert.Equal(CreateRequiredMessage(nameof(FileSystemEgressProviderOptions.DirectoryPath)), errorMessage);
+            string message = CreateRequiredMessage(nameof(FileSystemEgressProviderOptions), nameof(FileSystemEgressProviderOptions.DirectoryPath));
+            Assert.Equal($"{nameof(FileSystemEgressProviderOptions.DirectoryPath)}: {message}", errorMessage);
         }
 
         [Fact]
@@ -70,7 +72,7 @@ public async Task FileSystemEgressExtension_CopyBufferSizeZero_ThrowsException()
             OptionsValidationException exception = await Assert.ThrowsAsync<OptionsValidationException>(
                 () => extension.EgressArtifact(ProviderName, CreateSettings(), WriteFileContent, CancellationToken.None));
             string errorMessage = Assert.Single(exception.Failures);
-            Assert.Equal(CopyBufferSize_RangeErrorMessage, errorMessage);
+            Assert.Equal($"{nameof(FileSystemEgressProviderOptions.CopyBufferSize)}: {CopyBufferSize_RangeErrorMessage}", errorMessage);
         }
 
         [Fact]
@@ -175,14 +177,14 @@ private static EgressArtifactSettings CreateSettings()
             };
         }
 
-        private static string CreateRangeMessage<T>(string fieldName, string min, string max)
+        private static string CreateRangeMessage<T>(string typeName, string fieldName, string min, string max)
         {
-            return (new RangeAttribute(typeof(T), min, max)).FormatErrorMessage(fieldName);
+            return (new RangeAttribute(typeof(T), min, max)).FormatErrorMessage($"{typeName}.{fieldName}");
         }
 
-        private static string CreateRequiredMessage(string fieldName)
+        private static string CreateRequiredMessage(string typeName, string fieldName)
         {
-            return (new RequiredAttribute()).FormatErrorMessage(fieldName);
+            return (new RequiredAttribute()).FormatErrorMessage($"{typeName}.{fieldName}");
         }
 
         private static async Task WriteFileContent(Stream stream, CancellationToken token)
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/TemplatesTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/TemplatesTests.cs
index 307bedde981..182df0c8329 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/TemplatesTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/TemplatesTests.cs
@@ -98,8 +98,8 @@ await TestHostHelper.CreateCollectionRulesHost(_outputHelper, rootOptions => { }
                 string[] failures = ex.Failures.ToArray();
                 Assert.Equal(2, failures.Length);
 
-                Assert.Equal(string.Format(TemplateNotFoundErrorMessage, "TriggerTemplateINVALID"), failures[0]);
-                Assert.Equal(string.Format(TemplateNotFoundErrorMessage, "FilterTemplateINVALID"), failures[1]);
+                Assert.Equal(string.Format($"{nameof(CollectionRuleOptions.Trigger)}: {TemplateNotFoundErrorMessage}", "TriggerTemplateINVALID"), failures[0]);
+                Assert.Equal(string.Format($"{nameof(CollectionRuleOptions.Filters)}: {TemplateNotFoundErrorMessage}", "FilterTemplateINVALID"), failures[1]);
 
             }, overrideSource: GetConfigurationSources());
         }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectDumpAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectDumpAction.cs
index 9647ee347a0..47bb2333b72 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectDumpAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectDumpAction.cs
@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using System;
 using System.ComponentModel.DataAnnotations;
 using Utils = Microsoft.Diagnostics.Monitoring.WebApi.Utilities;
@@ -70,17 +71,22 @@ protected override EgressOperation CreateArtifactOperation(CollectionRuleMetadat
         }
     }
 
-    internal sealed class CollectDumpActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class CollectDumpActionDescriptor : ICollectionRuleActionDescriptor<CollectDumpOptions, CollectDumpActionFactory>
     {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectDumpActionDescriptor(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
         public string ActionName => KnownCollectionRuleActions.CollectDump;
-        public Type FactoryType => typeof(CollectDumpActionFactory);
-        public Type OptionsType => typeof(CollectDumpOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out CollectDumpOptions options)
         {
-            CollectDumpOptions options = new();
+            options = new();
             settingsSection.Bind_CollectDumpOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectExceptionsAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectExceptionsAction.cs
index e6aacfd4a99..ec0c27821a7 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectExceptionsAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectExceptionsAction.cs
@@ -7,6 +7,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
+using Microsoft.Extensions.Options;
 using System;
 using System.ComponentModel.DataAnnotations;
 using Utils = Microsoft.Diagnostics.Monitoring.WebApi.Utilities;
@@ -59,17 +60,22 @@ protected override EgressOperation CreateArtifactOperation(CollectionRuleMetadat
         }
     }
 
-    internal sealed class CollectExceptionsActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class CollectExceptionsActionDescriptor : ICollectionRuleActionDescriptor<CollectExceptionsOptions, CollectExceptionsActionFactory>
     {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectExceptionsActionDescriptor(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
         public string ActionName => KnownCollectionRuleActions.CollectExceptions;
-        public Type FactoryType => typeof(CollectExceptionsActionFactory);
-        public Type OptionsType => typeof(CollectExceptionsOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out CollectExceptionsOptions options)
         {
-            CollectExceptionsOptions options = new();
+            options = new();
             settingsSection.Bind_CollectExceptionsOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectGCDumpAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectGCDumpAction.cs
index 525be20357c..ca40464c397 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectGCDumpAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectGCDumpAction.cs
@@ -6,6 +6,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using System;
 using System.ComponentModel.DataAnnotations;
 using Utils = Microsoft.Diagnostics.Monitoring.WebApi.Utilities;
@@ -63,17 +64,22 @@ protected override EgressOperation CreateArtifactOperation(CollectionRuleMetadat
         }
     }
 
-    internal sealed class CollectGCDumpActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class CollectGCDumpActionDescriptor : ICollectionRuleActionDescriptor<CollectGCDumpOptions, CollectGCDumpActionFactory>
     {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectGCDumpActionDescriptor(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
         public string ActionName => KnownCollectionRuleActions.CollectGCDump;
-        public Type FactoryType => typeof(CollectGCDumpActionFactory);
-        public Type OptionsType => typeof(CollectGCDumpOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out CollectGCDumpOptions options)
         {
-            CollectGCDumpOptions options = new();
+            options = new();
             settingsSection.Bind_CollectGCDumpOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectLiveMetricsAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectLiveMetricsAction.cs
index d1c0d85be70..9e98e3504e0 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectLiveMetricsAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectLiveMetricsAction.cs
@@ -99,17 +99,22 @@ protected override EgressOperation CreateArtifactOperation(CollectionRuleMetadat
         }
     }
 
-    internal sealed class CollectLiveMetricsActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class CollectLiveMetricsActionDescriptor : ICollectionRuleActionDescriptor<CollectLiveMetricsOptions, CollectLiveMetricsActionFactory>
     {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectLiveMetricsActionDescriptor(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
         public string ActionName => KnownCollectionRuleActions.CollectLiveMetrics;
-        public Type FactoryType => typeof(CollectLiveMetricsActionFactory);
-        public Type OptionsType => typeof(CollectLiveMetricsOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out CollectLiveMetricsOptions options)
         {
-            CollectLiveMetricsOptions options = new();
+            options = new();
             settingsSection.Bind_CollectLiveMetricsOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectLogsAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectLogsAction.cs
index 8b85db24af2..a88037dd25c 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectLogsAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectLogsAction.cs
@@ -10,6 +10,7 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
@@ -87,17 +88,22 @@ protected override EgressOperation CreateArtifactOperation(CollectionRuleMetadat
         }
     }
 
-    internal sealed class CollectLogsActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class CollectLogsActionDescriptor : ICollectionRuleActionDescriptor<CollectLogsOptions, CollectLogsActionFactory>
     {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectLogsActionDescriptor(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
         public string ActionName => KnownCollectionRuleActions.CollectLogs;
-        public Type FactoryType => typeof(CollectLogsActionFactory);
-        public Type OptionsType => typeof(CollectLogsOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out CollectLogsOptions options)
         {
-            CollectLogsOptions options = new();
+            options = new();
             settingsSection.Bind_CollectLogsOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectStacksAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectStacksAction.cs
index e0cfb15b4b3..3de3fece73e 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectStacksAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectStacksAction.cs
@@ -7,6 +7,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
+using Microsoft.Extensions.Options;
 using System;
 using System.ComponentModel.DataAnnotations;
 using Utils = Microsoft.Diagnostics.Monitoring.WebApi.Utilities;
@@ -75,17 +76,22 @@ private static StackFormat MapCallStackFormat(CallStackFormat format) =>
             };
     }
 
-    internal sealed class CollectStacksActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class CollectStacksActionDescriptor : ICollectionRuleActionDescriptor<CollectStacksOptions, CollectStacksActionFactory>
     {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectStacksActionDescriptor(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
         public string ActionName => KnownCollectionRuleActions.CollectStacks;
-        public Type FactoryType => typeof(CollectStacksActionFactory);
-        public Type OptionsType => typeof(CollectStacksOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out CollectStacksOptions options)
         {
-            CollectStacksOptions options = new();
+            options = new();
             settingsSection.Bind_CollectStacksOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectTraceAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectTraceAction.cs
index a3c53868d36..52d57e1297c 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectTraceAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/CollectTraceAction.cs
@@ -111,17 +111,22 @@ protected override EgressOperation CreateArtifactOperation(CollectionRuleMetadat
         }
     }
 
-    internal sealed class CollectTraceActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class CollectTraceActionDescriptor : ICollectionRuleActionDescriptor<CollectTraceOptions, CollectTraceActionFactory>
     {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectTraceActionDescriptor(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
         public string ActionName => KnownCollectionRuleActions.CollectTrace;
-        public Type FactoryType => typeof(CollectTraceActionFactory);
-        public Type OptionsType => typeof(CollectTraceOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out CollectTraceOptions options)
         {
-            CollectTraceOptions options = new();
+            options = new();
             settingsSection.Bind_CollectTraceOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/ExecuteAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/ExecuteAction.cs
index 072bb23241b..2bd72e160b1 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/ExecuteAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/ExecuteAction.cs
@@ -7,6 +7,7 @@
 using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Configuration;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
@@ -109,17 +110,15 @@ internal static void ValidateExitCode(bool ignoreExitCode, int exitCode)
         }
     }
 
-    internal sealed class ExecuteActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class ExecuteActionDescriptor : ICollectionRuleActionDescriptor<ExecuteOptions, ExecuteActionFactory>
     {
         public string ActionName => KnownCollectionRuleActions.Execute;
-        public Type FactoryType => typeof(ExecuteActionFactory);
-        public Type OptionsType => typeof(ExecuteOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out ExecuteOptions options)
         {
-            ExecuteOptions options = new();
+            options = new();
             settingsSection.Bind_ExecuteOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/GetEnvironmentVariableAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/GetEnvironmentVariableAction.cs
index da2c1a777b7..2659886f005 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/GetEnvironmentVariableAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/GetEnvironmentVariableAction.cs
@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
@@ -87,17 +88,15 @@ protected override async Task<CollectionRuleActionResult> ExecuteCoreAsync(
         }
     }
 
-    internal sealed class GetEnvironmentVariableActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class GetEnvironmentVariableActionDescriptor : ICollectionRuleActionDescriptor<GetEnvironmentVariableOptions, GetEnvironmentVariableActionFactory>
     {
         public string ActionName => KnownCollectionRuleActions.GetEnvironmentVariable;
-        public Type OptionsType => typeof(GetEnvironmentVariableOptions);
-        public Type FactoryType => typeof(GetEnvironmentVariableActionFactory);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out GetEnvironmentVariableOptions options)
         {
-            GetEnvironmentVariableOptions options = new();
+            options = new();
             settingsSection.Bind_GetEnvironmentVariableOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/LoadProfilerAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/LoadProfilerAction.cs
index 46f336a90f5..5fcd6c53e0d 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/LoadProfilerAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/LoadProfilerAction.cs
@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
+using Microsoft.Extensions.Options;
 using System;
 using System.ComponentModel.DataAnnotations;
 using System.Threading;
@@ -72,17 +73,15 @@ protected override async Task<CollectionRuleActionResult> ExecuteCoreAsync(
         }
     }
 
-    internal sealed class LoadProfilerActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class LoadProfilerActionDescriptor : ICollectionRuleActionDescriptor<LoadProfilerOptions, LoadProfilerActionFactory>
     {
         public string ActionName => KnownCollectionRuleActions.LoadProfiler;
-        public Type FactoryType => typeof(LoadProfilerActionFactory);
-        public Type OptionsType => typeof(LoadProfilerOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out LoadProfilerOptions options)
         {
-            LoadProfilerOptions options = new();
+            options = new();
             settingsSection.Bind_LoadProfilerOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Actions/SetEnvironmentVariableAction.cs b/src/Tools/dotnet-monitor/CollectionRules/Actions/SetEnvironmentVariableAction.cs
index 66101ea2cdc..27a6c787464 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Actions/SetEnvironmentVariableAction.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Actions/SetEnvironmentVariableAction.cs
@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
+using Microsoft.Extensions.Options;
 using System;
 using System.ComponentModel.DataAnnotations;
 using System.Threading;
@@ -72,17 +73,15 @@ protected override async Task<CollectionRuleActionResult> ExecuteCoreAsync(
         }
     }
 
-    internal sealed class SetEnvironmentVariableActionDescriptor : ICollectionRuleActionDescriptor
+    [OptionsValidator]
+    internal sealed partial class SetEnvironmentVariableActionDescriptor : ICollectionRuleActionDescriptor<SetEnvironmentVariableOptions, SetEnvironmentVariableActionFactory>
     {
         public string ActionName => KnownCollectionRuleActions.SetEnvironmentVariable;
-        public Type FactoryType => typeof(SetEnvironmentVariableActionFactory);
-        public Type OptionsType => typeof(SetEnvironmentVariableOptions);
 
-        public void BindOptions(IConfigurationSection settingsSection, out object settings)
+        public void BindOptions(IConfigurationSection settingsSection, out SetEnvironmentVariableOptions options)
         {
-            SetEnvironmentVariableOptions options = new();
+            options = new();
             settingsSection.Bind_SetEnvironmentVariableOptions(options);
-            settings = options;
         }
     }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Configuration/ICollectionRuleActionDescriptor.cs b/src/Tools/dotnet-monitor/CollectionRules/Configuration/ICollectionRuleActionDescriptor.cs
index 7003561ffc7..6e02779a05e 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Configuration/ICollectionRuleActionDescriptor.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Configuration/ICollectionRuleActionDescriptor.cs
@@ -1,7 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
 using System;
 
 namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Configuration
@@ -16,4 +18,22 @@ internal interface ICollectionRuleActionDescriptor
 
         void BindOptions(IConfigurationSection settingsSection, out object settings);
     }
+
+    internal interface ICollectionRuleActionDescriptor<TOptions, TFactory>
+        : IValidateOptions<TOptions>, ICollectionRuleActionDescriptor
+        where TOptions : class
+        where TFactory : ICollectionRuleActionFactory<TOptions>
+    {
+        Type ICollectionRuleActionDescriptor.OptionsType => typeof(TOptions);
+
+        Type ICollectionRuleActionDescriptor.FactoryType => typeof(TFactory);
+
+        void BindOptions(IConfigurationSection settingsSection, out TOptions settings);
+
+        void ICollectionRuleActionDescriptor.BindOptions(IConfigurationSection settingsSection, out object settings)
+        {
+            BindOptions(settingsSection, out TOptions typedSettings);
+            settings = typedSettings;
+        }
+    }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Configuration/ICollectionRuleTriggerDescriptor.cs b/src/Tools/dotnet-monitor/CollectionRules/Configuration/ICollectionRuleTriggerDescriptor.cs
index aa167eddc2a..b0e5c281868 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Configuration/ICollectionRuleTriggerDescriptor.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Configuration/ICollectionRuleTriggerDescriptor.cs
@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
+using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers;
 using System;
 
 namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Configuration
@@ -16,4 +18,27 @@ interface ICollectionRuleTriggerDescriptor
 
         bool TryBindOptions(IConfigurationSection settingsSection, out object? settings);
     }
+
+    internal interface ICollectionRuleTriggerDescriptor<TOptions, TFactory>
+        : IValidateOptions<TOptions>, ICollectionRuleTriggerDescriptor
+        where TOptions : class
+        where TFactory : ICollectionRuleTriggerFactory<TOptions>
+    {
+        Type ICollectionRuleTriggerDescriptor.OptionsType => typeof(TOptions);
+
+        Type ICollectionRuleTriggerDescriptor.FactoryType => typeof(TFactory);
+
+        bool TryBindOptions(IConfigurationSection settingsSection, out TOptions settings);
+
+        bool ICollectionRuleTriggerDescriptor.TryBindOptions(IConfigurationSection settingsSection, out object? settings)
+        {
+            if (TryBindOptions(settingsSection, out TOptions typedSettings))
+            {
+                settings = typedSettings;
+                return true;
+            }
+            settings = null;
+            return false;
+        }
+    }
 }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectLiveMetricsOptions.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectLiveMetricsOptions.cs
index 7bba676bd59..0d267c670f5 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectLiveMetricsOptions.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectLiveMetricsOptions.cs
@@ -6,6 +6,7 @@
 using Microsoft.Diagnostics.Monitoring.WebApi;
 using Microsoft.Diagnostics.Monitoring.WebApi.Models;
 using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.CollectionRuleDefaultsInterfaces;
+using Microsoft.Extensions.Options;
 using System;
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
@@ -31,11 +32,13 @@ internal sealed partial record class CollectLiveMetricsOptions : BaseRecordOptio
         [Display(
             ResourceType = typeof(OptionsDisplayStrings),
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_CollectLiveMetricsOptions_Providers))]
+        [ValidateEnumeratedItems]
         public EventMetricsProvider[]? Providers { get; set; }
 
         [Display(
             ResourceType = typeof(OptionsDisplayStrings),
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_CollectLiveMetricsOptions_Meters))]
+        [ValidateEnumeratedItems]
         public EventMetricsMeter[]? Meters { get; set; }
 
         [Display(
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectLogsOptions.Validate.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectLogsOptions.Validate.cs
index e8ede3ded8c..d63fbc60438 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectLogsOptions.Validate.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectLogsOptions.Validate.cs
@@ -25,6 +25,7 @@ IEnumerable<ValidationResult> IValidatableObject.Validate(ValidationContext vali
 
                 ValidationContext filterSpecsContext = new(FilterSpecs, validationContext, validationContext.Items);
                 filterSpecsContext.MemberName = nameof(FilterSpecs);
+                filterSpecsContext.DisplayName = $"{nameof(CollectLogsOptions)}.{nameof(FilterSpecs)}";
 
                 // Validate that the category is not null and that the level is a valid level value.
                 foreach ((string category, LogLevel? level) in FilterSpecs)
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectTraceOptions.Validate.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectTraceOptions.Validate.cs
index 6874ec2354b..fa60ac0d19b 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectTraceOptions.Validate.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectTraceOptions.Validate.cs
@@ -87,11 +87,6 @@ IEnumerable<ValidationResult> IValidatableObject.Validate(ValidationContext vali
                 int index = 0;
                 foreach (EventPipeProvider provider in Providers)
                 {
-                    ValidationContext providerContext = new(provider, validationContext, validationContext.Items);
-                    providerContext.MemberName = nameof(Providers) + "[" + index.ToString(CultureInfo.InvariantCulture) + "]";
-
-                    Validator.TryValidateObject(provider, providerContext, results, validateAllProperties: true);
-
                     if (counterOptions != null && !CounterValidator.ValidateProvider(counterOptions, provider, out string? errorMessage))
                     {
                         results.Add(new ValidationResult(errorMessage, new[] { nameof(EventPipeProvider.Arguments) }));
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectTraceOptions.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectTraceOptions.cs
index 3a32d2a9460..bdacaa52001 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectTraceOptions.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/Actions/CollectTraceOptions.cs
@@ -6,6 +6,7 @@
 using Microsoft.Diagnostics.Monitoring.WebApi;
 using Microsoft.Diagnostics.Monitoring.WebApi.Models;
 using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.CollectionRuleDefaultsInterfaces;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -32,6 +33,7 @@ internal sealed partial record class CollectTraceOptions : BaseRecordOptions, IE
         [Display(
             ResourceType = typeof(OptionsDisplayStrings),
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_CollectTraceOptions_Providers))]
+        [ValidateEnumeratedItems]
         public List<EventPipeProvider>? Providers { get; set; }
 
         [Display(
@@ -68,6 +70,7 @@ internal sealed partial record class CollectTraceOptions : BaseRecordOptions, IE
         [Display(
             ResourceType = typeof(OptionsDisplayStrings),
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_CollectTraceOptions_StoppingEvent))]
+        [ValidateObjectMembers]
         public TraceEventFilter? StoppingEvent { get; set; }
 
         [Display(
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleActionOptionsValidator.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleActionOptionsValidator.cs
new file mode 100644
index 00000000000..2745fbf450c
--- /dev/null
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleActionOptionsValidator.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options
+{
+    [OptionsValidator]
+    sealed partial class CollectionRuleActionOptionsValidator : IValidateOptions<CollectionRuleActionOptions>
+    {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectionRuleActionOptionsValidator(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+    }
+}
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptions.Validate.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptions.Validate.cs
index 2af986cc1a8..de76f082bcf 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptions.Validate.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptions.Validate.cs
@@ -27,21 +27,6 @@ IEnumerable<ValidationResult> IValidatableObject.Validate(ValidationContext vali
                 return results;
             }
 
-            ValidationContext filtersContext = new(Filters, validationContext, validationContext.Items);
-            filtersContext.MemberName = nameof(Filters);
-            ValidationHelper.TryValidateItems(Filters, filtersContext, results);
-
-            if (null != Trigger)
-            {
-                ValidationContext triggerContext = new(Trigger, validationContext, validationContext.Items);
-                triggerContext.MemberName = nameof(Trigger);
-                Validator.TryValidateObject(Trigger, triggerContext, results);
-            }
-
-            ValidationContext actionsContext = new(Actions, validationContext, validationContext.Items);
-            actionsContext.MemberName = nameof(Actions);
-            ValidationHelper.TryValidateItems(Actions, actionsContext, results);
-
             var actionNames = new HashSet<string>(StringComparer.Ordinal);
             foreach (CollectionRuleActionOptions option in Actions)
             {
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptions.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptions.cs
index f8038fbcec7..461cfda4c1b 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptions.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptions.cs
@@ -4,6 +4,7 @@
 #nullable enable
 
 using Microsoft.Diagnostics.Monitoring.WebApi;
+using Microsoft.Extensions.Options;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 
@@ -17,6 +18,7 @@ internal sealed partial class CollectionRuleOptions
         [Display(
             ResourceType = typeof(OptionsDisplayStrings),
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_CollectionRuleOptions_Filters))]
+        [ValidateEnumeratedItems]
         public List<ProcessFilterDescriptor> Filters { get; set; } = [];
 
 #nullable disable
@@ -24,17 +26,20 @@ internal sealed partial class CollectionRuleOptions
             ResourceType = typeof(OptionsDisplayStrings),
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_CollectionRuleOptions_Trigger))]
         [Required]
+        [ValidateObjectMembers]
         public CollectionRuleTriggerOptions Trigger { get; set; }
 #nullable enable
 
         [Display(
             ResourceType = typeof(OptionsDisplayStrings),
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_CollectionRuleOptions_Actions))]
+        [ValidateEnumeratedItems]
         public List<CollectionRuleActionOptions> Actions { get; set; } = [];
 
         [Display(
             ResourceType = typeof(OptionsDisplayStrings),
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_CollectionRuleOptions_Limits))]
+        [ValidateObjectMembers]
         public CollectionRuleLimitsOptions? Limits { get; set; }
 
         // Configuration bindig source generator doesn't support ValidationResult
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptionsValidator.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptionsValidator.cs
new file mode 100644
index 00000000000..f973a350886
--- /dev/null
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleOptionsValidator.cs
@@ -0,0 +1,86 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options
+{
+    partial class CollectionRuleOptionsValidator : IValidateOptions<CollectionRuleOptions>
+    {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectionRuleOptionsValidator(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
+        private static readonly RequiredAttribute RequiredAttribute = new RequiredAttribute();
+
+        public ValidateOptionsResult Validate(string? name, CollectionRuleOptions options)
+        {
+            ValidateOptionsResultBuilder? builder = null;
+            string displayName = string.IsNullOrEmpty(name) ? "CollectionRuleOptions.Validate" : $"{name}.Validate";
+            var context = new ValidationContext(options, displayName, _serviceProvider, null);
+            var validationResults = new List<ValidationResult>();
+            var validationAttributes = new List<ValidationAttribute>(1);
+
+            context.MemberName = "Validate";
+            context.DisplayName = "CollectionRuleOptions.Validate";
+            var iValidatableObjectResults = ((IValidatableObject)options).Validate(context);
+            if (iValidatableObjectResults != null)
+            {
+                foreach (var result in iValidatableObjectResults)
+                {
+                    (builder ??= new()).AddResult(result);
+                }
+            }
+
+            if (builder is not null)
+            {
+                return builder.Build();
+            }
+
+            context.MemberName = "Trigger";
+            context.DisplayName = "CollectionRuleOptions.Trigger";
+            validationAttributes.Add(RequiredAttribute);
+            if (!Validator.TryValidateValue(options.Trigger, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            if (options.Trigger is not null)
+            {
+                (builder ??= new()).AddResult(new CollectionRuleTriggerOptionsValidator(_serviceProvider).Validate(string.IsNullOrEmpty(name) ? "CollectionRuleOptions.Trigger" : $"{name}.Trigger", options.Trigger));
+            }
+
+            if (options.Actions is not null)
+            {
+                var count = 0;
+                foreach (var o in options.Actions)
+                {
+                    if (o is not null)
+                    {
+                        (builder ??= new()).AddResult(new CollectionRuleActionOptionsValidator(_serviceProvider).Validate(string.IsNullOrEmpty(name) ? $"CollectionRuleOptions.Actions[{count}]" : $"{name}.Actions[{count}]", o));
+                    }
+                    else
+                    {
+                        (builder ??= new()).AddError(string.IsNullOrEmpty(name) ? $"CollectionRuleOptions.Actions[{count}] is null" : $"{name}.Actions[{count}] is null");
+                    }
+                    count++;
+                }
+            }
+
+            if (options.Limits is not null)
+            {
+                (builder ??= new()).AddResult(__CollectionRuleLimitsOptionsValidator__.Validate(string.IsNullOrEmpty(name) ? "CollectionRuleOptions.Limits" : $"{name}.Limits", options.Limits));
+            }
+
+            return builder is null ? ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleTriggerOptionsValidator.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleTriggerOptionsValidator.cs
new file mode 100644
index 00000000000..abed8482367
--- /dev/null
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/CollectionRuleTriggerOptionsValidator.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options
+{
+    [OptionsValidator]
+    partial class CollectionRuleTriggerOptionsValidator : IValidateOptions<CollectionRuleTriggerOptions>
+    {
+        private readonly IServiceProvider _serviceProvider;
+
+        public CollectionRuleTriggerOptionsValidator(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+    }
+}
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Options/ValidationHelper.cs b/src/Tools/dotnet-monitor/CollectionRules/Options/ValidationHelper.cs
index c99543df9c0..0c5230036ba 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Options/ValidationHelper.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Options/ValidationHelper.cs
@@ -12,20 +12,6 @@ namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options
 {
     internal static class ValidationHelper
     {
-        public static void TryValidateItems(IEnumerable<object> items, ValidationContext validationContext, ICollection<ValidationResult> results)
-        {
-            int index = 0;
-            foreach (object item in items)
-            {
-                ValidationContext itemContext = new(item, validationContext, validationContext.Items);
-                itemContext.MemberName = validationContext.MemberName + "[" + index.ToString() + "]";
-
-                Validator.TryValidateObject(item, itemContext, results);
-
-                index++;
-            }
-        }
-
 #nullable disable
         public static bool TryValidateOptions(Type optionsType, object options, ValidationContext validationContext, ICollection<ValidationResult> results)
         {
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetRequestCountTriggerFactory.cs b/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetRequestCountTriggerFactory.cs
index 59f808b96e7..4d427833c8e 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetRequestCountTriggerFactory.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetRequestCountTriggerFactory.cs
@@ -11,6 +11,7 @@
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
 using System;
 using System.Globalization;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers
 {
@@ -48,17 +49,15 @@ public ICollectionRuleTrigger Create(IEndpointInfo endpointInfo, Action callback
         }
     }
 
-    internal sealed class AspNetRequestCountTriggerDescriptor : ICollectionRuleTriggerDescriptor
+    [OptionsValidator]
+    internal sealed partial class AspNetRequestCountTriggerDescriptor : ICollectionRuleTriggerDescriptor<AspNetRequestCountOptions, AspNetRequestCountTriggerFactory>
     {
-        public Type FactoryType => typeof(AspNetRequestCountTriggerFactory);
-        public Type? OptionsType => typeof(AspNetRequestCountOptions);
         public string TriggerName => KnownCollectionRuleTriggers.AspNetRequestCount;
 
-        public bool TryBindOptions(IConfigurationSection settingsSection, out object? settings)
+        public bool TryBindOptions(IConfigurationSection settingsSection, out AspNetRequestCountOptions options)
         {
-            var options = new AspNetRequestCountOptions();
+            options = new AspNetRequestCountOptions();
             settingsSection.Bind_AspNetRequestCountOptions(options);
-            settings = options;
             return true;
         }
     }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetRequestDurationTriggerFactory.cs b/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetRequestDurationTriggerFactory.cs
index cae2ed3ac1f..7cce21e2793 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetRequestDurationTriggerFactory.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetRequestDurationTriggerFactory.cs
@@ -54,17 +54,15 @@ public ICollectionRuleTrigger Create(IEndpointInfo endpointInfo, Action callback
         }
     }
 
-    internal sealed class AspNetRequestDurationTriggerDescriptor : ICollectionRuleTriggerDescriptor
+    [OptionsValidator]
+    internal sealed partial class AspNetRequestDurationTriggerDescriptor : ICollectionRuleTriggerDescriptor<AspNetRequestDurationOptions, AspNetRequestDurationTriggerFactory>
     {
-        public Type FactoryType => typeof(AspNetRequestDurationTriggerFactory);
-        public Type? OptionsType => typeof(AspNetRequestDurationOptions);
         public string TriggerName => KnownCollectionRuleTriggers.AspNetRequestDuration;
 
-        public bool TryBindOptions(IConfigurationSection settingsSection, out object? settings)
+        public bool TryBindOptions(IConfigurationSection settingsSection, out AspNetRequestDurationOptions options)
         {
-            var options = new AspNetRequestDurationOptions();
+            options = new AspNetRequestDurationOptions();
             settingsSection.Bind_AspNetRequestDurationOptions(options);
-            settings = options;
             return true;
         }
     }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetResponseStatusTriggerFactory.cs b/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetResponseStatusTriggerFactory.cs
index 2e4bce415dc..75756453255 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetResponseStatusTriggerFactory.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Triggers/AspNetResponseStatusTriggerFactory.cs
@@ -9,6 +9,7 @@
 using Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Configuration;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.Binder.SourceGeneration;
+using Microsoft.Extensions.Options;
 using System;
 using System.Globalization;
 using System.Linq;
@@ -63,17 +64,15 @@ private static StatusCodeRange ParseRange(string range)
         }
     }
 
-    internal sealed class AspNetResponseStatusTriggerDescriptor : ICollectionRuleTriggerDescriptor
+    [OptionsValidator]
+    internal sealed partial class AspNetResponseStatusTriggerDescriptor : ICollectionRuleTriggerDescriptor<AspNetResponseStatusOptions, AspNetResponseStatusTriggerFactory>
     {
-        public Type FactoryType => typeof(AspNetResponseStatusTriggerFactory);
-        public Type? OptionsType => typeof(AspNetResponseStatusOptions);
         public string TriggerName => KnownCollectionRuleTriggers.AspNetResponseStatus;
 
-        public bool TryBindOptions(IConfigurationSection settingsSection, out object? settings)
+        public bool TryBindOptions(IConfigurationSection settingsSection, out AspNetResponseStatusOptions options)
         {
-            var options = new AspNetResponseStatusOptions();
+            options = new AspNetResponseStatusOptions();
             settingsSection.Bind_AspNetResponseStatusOptions(options);
-            settings = options;
             return true;
         }
     }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Triggers/EventCounterTriggerFactory.cs b/src/Tools/dotnet-monitor/CollectionRules/Triggers/EventCounterTriggerFactory.cs
index c2f9a4c8635..2c295ecc47f 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Triggers/EventCounterTriggerFactory.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Triggers/EventCounterTriggerFactory.cs
@@ -113,62 +113,54 @@ internal static EventCounterOptions ToEventCounterOptions(IEventCounterShortcuts
         }
     }
 
-    internal sealed class EventCounterTriggerDescriptor : ICollectionRuleTriggerDescriptor
+    [OptionsValidator]
+    internal sealed partial class EventCounterTriggerDescriptor : ICollectionRuleTriggerDescriptor<EventCounterOptions, EventCounterTriggerFactory>
     {
-        public Type FactoryType => typeof(EventCounterTriggerFactory);
-        public Type? OptionsType => typeof(EventCounterOptions);
         public string TriggerName => KnownCollectionRuleTriggers.EventCounter;
 
-        public bool TryBindOptions(IConfigurationSection settingsSection, out object? settings)
+        public bool TryBindOptions(IConfigurationSection settingsSection, out EventCounterOptions options)
         {
-            var options = new EventCounterOptions();
+            options = new EventCounterOptions();
             settingsSection.Bind_EventCounterOptions(options);
-            settings = options;
             return true;
         }
     }
 
-    internal sealed class CPUUsageTriggerDescriptor : ICollectionRuleTriggerDescriptor
+    [OptionsValidator]
+    internal sealed partial class CPUUsageTriggerDescriptor : ICollectionRuleTriggerDescriptor<CPUUsageOptions, EventCounterTriggerFactory>
     {
-        public Type FactoryType => typeof(EventCounterTriggerFactory);
-        public Type? OptionsType => typeof(CPUUsageOptions);
         public string TriggerName => KnownCollectionRuleTriggers.CPUUsage;
 
-        public bool TryBindOptions(IConfigurationSection settingsSection, out object? settings)
+        public bool TryBindOptions(IConfigurationSection settingsSection, out CPUUsageOptions options)
         {
-            var options = new CPUUsageOptions();
+            options = new CPUUsageOptions();
             settingsSection.Bind_CPUUsageOptions(options);
-            settings = options;
             return true;
         }
     }
 
-    internal sealed class GCHeapSizeTriggerDescriptor : ICollectionRuleTriggerDescriptor
+    [OptionsValidator]
+    internal sealed partial class GCHeapSizeTriggerDescriptor : ICollectionRuleTriggerDescriptor<GCHeapSizeOptions, EventCounterTriggerFactory>
     {
-        public Type FactoryType => typeof(EventCounterTriggerFactory);
-        public Type? OptionsType => typeof(GCHeapSizeOptions);
         public string TriggerName => KnownCollectionRuleTriggers.GCHeapSize;
 
-        public bool TryBindOptions(IConfigurationSection settingsSection, out object? settings)
+        public bool TryBindOptions(IConfigurationSection settingsSection, out GCHeapSizeOptions options)
         {
-            var options = new GCHeapSizeOptions();
+            options = new GCHeapSizeOptions();
             settingsSection.Bind_GCHeapSizeOptions(options);
-            settings = options;
             return true;
         }
     }
 
-    internal sealed class ThreadpoolQueueLengthTriggerDescriptor : ICollectionRuleTriggerDescriptor
+    [OptionsValidator]
+    internal sealed partial class ThreadpoolQueueLengthTriggerDescriptor : ICollectionRuleTriggerDescriptor<ThreadpoolQueueLengthOptions, EventCounterTriggerFactory>
     {
-        public Type FactoryType => typeof(EventCounterTriggerFactory);
-        public Type? OptionsType => typeof(ThreadpoolQueueLengthOptions);
         public string TriggerName => KnownCollectionRuleTriggers.ThreadpoolQueueLength;
 
-        public bool TryBindOptions(IConfigurationSection settingsSection, out object? settings)
+        public bool TryBindOptions(IConfigurationSection settingsSection, out ThreadpoolQueueLengthOptions options)
         {
-            var options = new ThreadpoolQueueLengthOptions();
+            options = new ThreadpoolQueueLengthOptions();
             settingsSection.Bind_ThreadpoolQueueLengthOptions(options);
-            settings = options;
             return true;
         }
     }
diff --git a/src/Tools/dotnet-monitor/CollectionRules/Triggers/EventMeterTriggerFactory.cs b/src/Tools/dotnet-monitor/CollectionRules/Triggers/EventMeterTriggerFactory.cs
index 41bd60e5bb9..40ce8677818 100644
--- a/src/Tools/dotnet-monitor/CollectionRules/Triggers/EventMeterTriggerFactory.cs
+++ b/src/Tools/dotnet-monitor/CollectionRules/Triggers/EventMeterTriggerFactory.cs
@@ -59,17 +59,15 @@ public ICollectionRuleTrigger Create(IEndpointInfo endpointInfo, Action callback
         }
     }
 
-    internal sealed class EventMeterTriggerDescriptor : ICollectionRuleTriggerDescriptor
+    [OptionsValidator]
+    internal sealed partial class EventMeterTriggerDescriptor : ICollectionRuleTriggerDescriptor<EventMeterOptions, EventMeterTriggerFactory>
     {
-        public Type FactoryType => typeof(EventMeterTriggerFactory);
-        public Type? OptionsType => typeof(EventMeterOptions);
         public string TriggerName => KnownCollectionRuleTriggers.EventMeter;
 
-        public bool TryBindOptions(IConfigurationSection settingsSection, out object? settings)
+        public bool TryBindOptions(IConfigurationSection settingsSection, out EventMeterOptions options)
         {
-            var options = new EventMeterOptions();
+            options = new EventMeterOptions();
             settingsSection.Bind_EventMeterOptions(options);
-            settings = options;
             return true;
         }
     }
diff --git a/src/Tools/dotnet-monitor/DataAnnotationValidateOptions.cs b/src/Tools/dotnet-monitor/DataAnnotationValidateOptions.cs
deleted file mode 100644
index 2b6548a03b3..00000000000
--- a/src/Tools/dotnet-monitor/DataAnnotationValidateOptions.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using Microsoft.Extensions.Options;
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.ComponentModel.DataAnnotations;
-
-#if EXTENSION
-namespace Microsoft.Diagnostics.Monitoring.Extension.Common
-#else
-namespace Microsoft.Diagnostics.Tools.Monitor
-#endif
-{
-    internal sealed class DataAnnotationValidateOptions<TOptions> :
-        IValidateOptions<TOptions>
-        where TOptions : class
-    {
-        private readonly IServiceProvider _serviceProvider;
-
-        public DataAnnotationValidateOptions(IServiceProvider serviceProvider)
-        {
-            _serviceProvider = serviceProvider;
-        }
-
-        public ValidateOptionsResult Validate(string? name, TOptions options)
-        {
-            ValidationContext validationContext = new(options, _serviceProvider, null);
-            ICollection<ValidationResult> results = new Collection<ValidationResult>();
-            if (!Validator.TryValidateObject(options, validationContext, results, validateAllProperties: true))
-            {
-                IList<string> failures = new List<string>();
-                foreach (ValidationResult result in results)
-                {
-                    if (ValidationResult.Success != result)
-                    {
-#nullable disable
-                        failures.Add(result.ErrorMessage);
-#nullable restore
-                    }
-                }
-
-                if (failures.Count > 0)
-                {
-                    return ValidateOptionsResult.Fail(failures);
-                }
-            }
-
-            return ValidateOptionsResult.Success;
-        }
-    }
-}
diff --git a/src/Tools/dotnet-monitor/Egress/FileSystem/FileSystemEgressExtension.cs b/src/Tools/dotnet-monitor/Egress/FileSystem/FileSystemEgressExtension.cs
index 560bbe3be1b..f940b79a790 100644
--- a/src/Tools/dotnet-monitor/Egress/FileSystem/FileSystemEgressExtension.cs
+++ b/src/Tools/dotnet-monitor/Egress/FileSystem/FileSystemEgressExtension.cs
@@ -206,7 +206,7 @@ private FileSystemEgressProviderOptions ValidateOptions(string providerName)
             FileSystemEgressProviderOptions options = new();
             configuration.Bind_FileSystemEgressProviderOptions(options);
 
-            DataAnnotationValidateOptions<FileSystemEgressProviderOptions> validateOptions = new(_serviceProvider);
+            IValidateOptions<FileSystemEgressProviderOptions> validateOptions = new FileSystemEgressProviderOptionsValidator(_serviceProvider);
             var validationResult = validateOptions.Validate(providerName, options);
 
             if (validationResult.Failed)
diff --git a/src/Tools/dotnet-monitor/ServiceCollectionExtensions.cs b/src/Tools/dotnet-monitor/ServiceCollectionExtensions.cs
index b544d9960e4..5fdd1b33bb1 100644
--- a/src/Tools/dotnet-monitor/ServiceCollectionExtensions.cs
+++ b/src/Tools/dotnet-monitor/ServiceCollectionExtensions.cs
@@ -60,7 +60,8 @@ public static IServiceCollection ConfigureDotnetMonitorDebug(this IServiceCollec
         public static IServiceCollection ConfigureGlobalCounter(this IServiceCollection services, IConfiguration configuration)
         {
             return services.Configure<GlobalCounterOptions>(configuration.GetSection(ConfigurationKeys.GlobalCounter))
-                .AddSingleton<IValidateOptions<GlobalCounterOptions>, DataAnnotationValidateOptions<GlobalCounterOptions>>();
+                .AddSingleton<IValidateOptions<GlobalCounterOptions>, GlobalCounterOptionsValidator>()
+                .AddSingleton<IValidateOptions<GlobalProviderOptions>, GlobalProviderOptionsValidator>();
 
         }
 
@@ -95,7 +96,7 @@ public static IServiceCollection ConfigureInProcessFeatures(this IServiceCollect
         public static IServiceCollection ConfigureMetrics(this IServiceCollection services, IConfiguration configuration)
         {
             return services.Configure<MetricsOptions>(configuration.GetSection(ConfigurationKeys.Metrics))
-                .AddSingleton<IValidateOptions<MetricsOptions>, DataAnnotationValidateOptions<MetricsOptions>>()
+                .AddSingleton<IValidateOptions<MetricsOptions>, MetricsOptionsValidator>()
                 .AddSingleton<MetricsStoreService>()
                 .AddHostedService<MetricsService>()
                 .AddSingleton<IMetricsPortsProvider, MetricsPortsProvider>();
@@ -178,7 +179,7 @@ public static IServiceCollection ConfigureCollectionRules(this IServiceCollectio
             services.AddSingleton<IConfigureOptions<CollectionRuleOptions>, CollectionRuleConfigureNamedOptions>();
             services.AddSingleton<IPostConfigureOptions<CollectionRuleOptions>, CollectionRulePostConfigureOptions>();
             services.AddSingleton<IPostConfigureOptions<CollectionRuleOptions>, DefaultCollectionRulePostConfigureOptions>();
-            services.AddSingleton<IValidateOptions<CollectionRuleOptions>, DataAnnotationValidateOptions<CollectionRuleOptions>>();
+            services.AddSingleton<IValidateOptions<CollectionRuleOptions>, CollectionRuleOptionsValidator>();
 
             // Register change sources for the options type
             services.AddSingleton<IOptionsChangeTokenSource<CollectionRuleOptions>, CollectionRulesConfigurationChangeTokenSource>();
@@ -199,14 +200,14 @@ public static IServiceCollection ConfigureCollectionRules(this IServiceCollectio
         public static IServiceCollection RegisterCollectionRuleAction<TFactory, TOptions, TDescriptor>(this IServiceCollection services)
             where TFactory : class, ICollectionRuleActionFactory<TOptions>
             where TOptions : BaseRecordOptions, new()
-            where TDescriptor : class, ICollectionRuleActionDescriptor
+            where TDescriptor : class, ICollectionRuleActionDescriptor<TOptions, TFactory>
         {
             services.AddSingleton<TFactory>();
             services.AddSingleton<CollectionRuleActionFactoryProxy<TFactory, TOptions>>();
             services.AddSingleton<ICollectionRuleActionDescriptor, TDescriptor>();
             // NOTE: When opening collection rule actions for extensibility, this should not be added for all registered actions.
             // Each action should register its own IValidateOptions<> implementation (if it needs one).
-            services.AddSingleton<IValidateOptions<TOptions>, DataAnnotationValidateOptions<TOptions>>();
+            services.AddSingleton<IValidateOptions<TOptions>, TDescriptor>();
             return services;
         }
 
@@ -223,14 +224,14 @@ public static IServiceCollection RegisterCollectionRuleTrigger<TFactory, TDescri
         public static IServiceCollection RegisterCollectionRuleTrigger<TFactory, TOptions, TDescriptor>(this IServiceCollection services)
             where TFactory : class, ICollectionRuleTriggerFactory<TOptions>
             where TOptions : class, new()
-            where TDescriptor : class, ICollectionRuleTriggerDescriptor
+            where TDescriptor : class, ICollectionRuleTriggerDescriptor<TOptions, TFactory>
         {
             services.AddSingleton<TFactory>();
             services.AddSingleton<CollectionRuleTriggerFactoryProxy<TFactory, TOptions>>();
             services.AddSingleton<ICollectionRuleTriggerDescriptor, TDescriptor>();
             // NOTE: When opening collection rule triggers for extensibility, this should not be added for all registered triggers.
             // Each trigger should register its own IValidateOptions<> implementation (if it needs one).
-            services.AddSingleton<IValidateOptions<TOptions>, DataAnnotationValidateOptions<TOptions>>();
+            services.AddSingleton<IValidateOptions<TOptions>, TDescriptor>();
 
             return services;
         }
diff --git a/src/Tools/dotnet-monitor/Validators.cs b/src/Tools/dotnet-monitor/Validators.cs
new file mode 100644
index 00000000000..cf4e39fd12c
--- /dev/null
+++ b/src/Tools/dotnet-monitor/Validators.cs
@@ -0,0 +1,1788 @@
+
+    // <auto-generated/>
+    #nullable enable
+    #pragma warning disable CS1591 // Compensate for https://github.com/dotnet/roslyn/issues/54103
+    namespace Microsoft.Diagnostics.Monitoring.WebApi.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    internal sealed partial class __EventMetricsMeterValidator__
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public static global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Monitoring.WebApi.Models.EventMetricsMeter options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "EventMetricsMeter.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "MeterName";
+            context.DisplayName = "EventMetricsMeter.MeterName";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A2);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.MeterName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Monitoring.WebApi.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    internal sealed partial class __EventMetricsProviderValidator__
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public static global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Monitoring.WebApi.Models.EventMetricsProvider options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "EventMetricsProvider.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "ProviderName";
+            context.DisplayName = "EventMetricsProvider.ProviderName";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A2);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.ProviderName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Monitoring.WebApi.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    internal sealed partial class __EventPipeProviderValidator__
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public static global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Monitoring.WebApi.Models.EventPipeProvider options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "EventPipeProvider.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "Name";
+            context.DisplayName = "EventPipeProvider.Name";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A2);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Name, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Keywords";
+            context.DisplayName = "EventPipeProvider.Keywords";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A3);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Keywords, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "EventLevel";
+            context.DisplayName = "EventPipeProvider.EventLevel";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A4);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.EventLevel, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class CollectDumpActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.CollectDumpOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectDumpOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "Type";
+            context.DisplayName = "CollectDumpOptions.Type";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A5);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Type, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Egress";
+            context.DisplayName = "CollectDumpOptions.Egress";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A6);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A7);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Egress, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class CollectExceptionsActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.CollectExceptionsOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectExceptionsOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "Egress";
+            context.DisplayName = "CollectExceptionsOptions.Egress";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A6);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A7);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Egress, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "CollectExceptionsOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class CollectGCDumpActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.CollectGCDumpOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectGCDumpOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "Egress";
+            context.DisplayName = "CollectGCDumpOptions.Egress";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A6);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A7);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Egress, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class CollectLiveMetricsActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.CollectLiveMetricsOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectLiveMetricsOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            if (options.Providers is not null)
+            {
+                var count = 0;
+                foreach (var o in options.Providers)
+                {
+                    if (o is not null)
+                    {
+                        (builder ??= new()).AddResult(global::Microsoft.Diagnostics.Monitoring.WebApi.Models.__EventMetricsProviderValidator__.Validate(string.IsNullOrEmpty(name) ? $"CollectLiveMetricsOptions.Providers[{count}]" : $"{name}.Providers[{count}]", o));
+                    }
+                    else
+                    {
+                        (builder ??= new()).AddError(string.IsNullOrEmpty(name) ? $"CollectLiveMetricsOptions.Providers[{count}] is null" : $"{name}.Providers[{count}] is null");
+                    }
+                    count++;
+                }
+            }
+
+            if (options.Meters is not null)
+            {
+                var count = 0;
+                foreach (var o in options.Meters)
+                {
+                    if (o is not null)
+                    {
+                        (builder ??= new()).AddResult(global::Microsoft.Diagnostics.Monitoring.WebApi.Models.__EventMetricsMeterValidator__.Validate(string.IsNullOrEmpty(name) ? $"CollectLiveMetricsOptions.Meters[{count}]" : $"{name}.Meters[{count}]", o));
+                    }
+                    else
+                    {
+                        (builder ??= new()).AddError(string.IsNullOrEmpty(name) ? $"CollectLiveMetricsOptions.Meters[{count}] is null" : $"{name}.Meters[{count}] is null");
+                    }
+                    count++;
+                }
+            }
+
+            context.MemberName = "Duration";
+            context.DisplayName = "CollectLiveMetricsOptions.Duration";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Duration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Egress";
+            context.DisplayName = "CollectLiveMetricsOptions.Egress";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A6);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A7);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Egress, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class CollectLogsActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.CollectLogsOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectLogsOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "DefaultLevel";
+            context.DisplayName = "CollectLogsOptions.DefaultLevel";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A9);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.DefaultLevel, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Duration";
+            context.DisplayName = "CollectLogsOptions.Duration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Duration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Egress";
+            context.DisplayName = "CollectLogsOptions.Egress";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A6);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A7);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Egress, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Format";
+            context.DisplayName = "CollectLogsOptions.Format";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A10);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Format, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "CollectLogsOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class CollectStacksActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.CollectStacksOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectStacksOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "Egress";
+            context.DisplayName = "CollectStacksOptions.Egress";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A6);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A7);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Egress, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "CollectStacksOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class CollectTraceActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.CollectTraceOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectTraceOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "Profile";
+            context.DisplayName = "CollectTraceOptions.Profile";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A11);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Profile, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            if (options.Providers is not null)
+            {
+                var count = 0;
+                foreach (var o in options.Providers)
+                {
+                    if (o is not null)
+                    {
+                        (builder ??= new()).AddResult(global::Microsoft.Diagnostics.Monitoring.WebApi.Models.__EventPipeProviderValidator__.Validate(string.IsNullOrEmpty(name) ? $"CollectTraceOptions.Providers[{count}]" : $"{name}.Providers[{count}]", o));
+                    }
+                    else
+                    {
+                        (builder ??= new()).AddError(string.IsNullOrEmpty(name) ? $"CollectTraceOptions.Providers[{count}] is null" : $"{name}.Providers[{count}] is null");
+                    }
+                    count++;
+                }
+            }
+
+            context.MemberName = "BufferSizeMegabytes";
+            context.DisplayName = "CollectTraceOptions.BufferSizeMegabytes";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A12);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.BufferSizeMegabytes, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Duration";
+            context.DisplayName = "CollectTraceOptions.Duration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Duration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Egress";
+            context.DisplayName = "CollectTraceOptions.Egress";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A6);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A7);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Egress, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            if (options.StoppingEvent is not null)
+            {
+                (builder ??= new()).AddResult(global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.__TraceEventFilterValidator__.Validate(string.IsNullOrEmpty(name) ? "CollectTraceOptions.StoppingEvent" : $"{name}.StoppingEvent", options.StoppingEvent));
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "CollectTraceOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class ExecuteActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.ExecuteOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "ExecuteOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "Path";
+            context.DisplayName = "ExecuteOptions.Path";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Path, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class GetEnvironmentVariableActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.GetEnvironmentVariableOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "GetEnvironmentVariableOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "Name";
+            context.DisplayName = "GetEnvironmentVariableOptions.Name";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Name, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class LoadProfilerActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.LoadProfilerOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "LoadProfilerOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "Path";
+            context.DisplayName = "LoadProfilerOptions.Path";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Path, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Clsid";
+            context.DisplayName = "LoadProfilerOptions.Clsid";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A13);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Clsid, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Actions
+{
+    partial class SetEnvironmentVariableActionDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.SetEnvironmentVariableOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "SetEnvironmentVariableOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "Name";
+            context.DisplayName = "SetEnvironmentVariableOptions.Name";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Name, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    internal sealed partial class __CollectionRuleLimitsOptionsValidator__
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public static global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.CollectionRuleLimitsOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectionRuleLimitsOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "ActionCount";
+            context.DisplayName = "CollectionRuleLimitsOptions.ActionCount";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A14);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.ActionCount, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "ActionCountSlidingWindowDuration";
+            context.DisplayName = "CollectionRuleLimitsOptions.ActionCountSlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.ActionCountSlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "RuleDuration";
+            context.DisplayName = "CollectionRuleLimitsOptions.RuleDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A15);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.RuleDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    internal sealed partial class __TraceEventFilterValidator__
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public static global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.TraceEventFilter options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "TraceEventFilter.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "ProviderName";
+            context.DisplayName = "TraceEventFilter.ProviderName";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.ProviderName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "EventName";
+            context.DisplayName = "TraceEventFilter.EventName";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.EventName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options
+{
+    partial class CollectionRuleActionOptionsValidator
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.CollectionRuleActionOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectionRuleActionOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "Type";
+            context.DisplayName = "CollectionRuleActionOptions.Type";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Type, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "CollectionRuleActionOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options
+{
+    partial class CollectionRuleTriggerOptionsValidator
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.CollectionRuleTriggerOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CollectionRuleTriggerOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, _serviceProvider, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "Type";
+            context.DisplayName = "CollectionRuleTriggerOptions.Type";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.Type, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "CollectionRuleTriggerOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers
+{
+    partial class EventCounterOptions
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers.EventCounterOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "EventCounterOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "ProviderName";
+            context.DisplayName = "EventCounterOptions.ProviderName";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.ProviderName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "CounterName";
+            context.DisplayName = "EventCounterOptions.CounterName";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.CounterName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "SlidingWindowDuration";
+            context.DisplayName = "EventCounterOptions.SlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.SlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "EventCounterOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers
+{
+    partial class AspNetRequestCountTriggerDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers.AspNetRequestCountOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "AspNetRequestCountOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "RequestCount";
+            context.DisplayName = "AspNetRequestCountOptions.RequestCount";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A16);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A14);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.RequestCount, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "SlidingWindowDuration";
+            context.DisplayName = "AspNetRequestCountOptions.SlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.SlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers
+{
+    partial class AspNetRequestDurationTriggerDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers.AspNetRequestDurationOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "AspNetRequestDurationOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(2);
+
+            context.MemberName = "RequestCount";
+            context.DisplayName = "AspNetRequestDurationOptions.RequestCount";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A16);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A14);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.RequestCount, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "RequestDuration";
+            context.DisplayName = "AspNetRequestDurationOptions.RequestDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A17);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.RequestDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "SlidingWindowDuration";
+            context.DisplayName = "AspNetRequestDurationOptions.SlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.SlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers
+{
+    partial class AspNetResponseStatusTriggerDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers.AspNetResponseStatusOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "AspNetResponseStatusOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(3);
+
+            context.MemberName = "StatusCodes";
+            context.DisplayName = "AspNetResponseStatusOptions.StatusCodes";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A2);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A18);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.StatusCodes, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "ResponseCount";
+            context.DisplayName = "AspNetResponseStatusOptions.ResponseCount";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A19);
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A14);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.ResponseCount, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "SlidingWindowDuration";
+            context.DisplayName = "AspNetResponseStatusOptions.SlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.SlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers
+{
+    partial class CPUUsageTriggerDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers.EventCounterShortcuts.CPUUsageOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "CPUUsageOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "GreaterThan";
+            context.DisplayName = "CPUUsageOptions.GreaterThan";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A20);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.GreaterThan, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "LessThan";
+            context.DisplayName = "CPUUsageOptions.LessThan";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A20);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.LessThan, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "SlidingWindowDuration";
+            context.DisplayName = "CPUUsageOptions.SlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.SlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "CPUUsageOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers
+{
+    partial class EventCounterTriggerDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers.EventCounterOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "EventCounterOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "ProviderName";
+            context.DisplayName = "EventCounterOptions.ProviderName";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.ProviderName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "CounterName";
+            context.DisplayName = "EventCounterOptions.CounterName";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.CounterName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "SlidingWindowDuration";
+            context.DisplayName = "EventCounterOptions.SlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.SlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "EventCounterOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers
+{
+    partial class EventMeterTriggerDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers.EventMeterOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "EventMeterOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "MeterName";
+            context.DisplayName = "EventMeterOptions.MeterName";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.MeterName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "InstrumentName";
+            context.DisplayName = "EventMeterOptions.InstrumentName";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A1);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.InstrumentName, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "SlidingWindowDuration";
+            context.DisplayName = "EventMeterOptions.SlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.SlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "HistogramPercentile";
+            context.DisplayName = "EventMeterOptions.HistogramPercentile";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A20);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.HistogramPercentile, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "EventMeterOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers
+{
+    partial class GCHeapSizeTriggerDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers.EventCounterShortcuts.GCHeapSizeOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "GCHeapSizeOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "GreaterThan";
+            context.DisplayName = "GCHeapSizeOptions.GreaterThan";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A21);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.GreaterThan, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "LessThan";
+            context.DisplayName = "GCHeapSizeOptions.LessThan";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A21);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.LessThan, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "SlidingWindowDuration";
+            context.DisplayName = "GCHeapSizeOptions.SlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.SlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "GCHeapSizeOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Triggers
+{
+    partial class ThreadpoolQueueLengthTriggerDescriptor
+    {
+        /// <summary>
+        /// Validates a specific named options instance (or all when <paramref name="name"/> is <see langword="null" />).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <returns>Validation result.</returns>
+        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+        #if !NET10_0_OR_GREATER
+        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode",
+             Justification = "The created ValidationContext object is used in a way that never call reflection")]
+        #endif
+        public global::Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Triggers.EventCounterShortcuts.ThreadpoolQueueLengthOptions options)
+        {
+            global::Microsoft.Extensions.Options.ValidateOptionsResultBuilder? builder = null;
+            #if NET10_0_OR_GREATER
+            string displayName = string.IsNullOrEmpty(name) ? "ThreadpoolQueueLengthOptions.Validate" : $"{name}.Validate";
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options, displayName, null, null);
+            #else
+            var context = new global::System.ComponentModel.DataAnnotations.ValidationContext(options);
+            #endif
+            var validationResults = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationResult>();
+            var validationAttributes = new global::System.Collections.Generic.List<global::System.ComponentModel.DataAnnotations.ValidationAttribute>(1);
+
+            context.MemberName = "GreaterThan";
+            context.DisplayName = "ThreadpoolQueueLengthOptions.GreaterThan";
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A21);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.GreaterThan, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "LessThan";
+            context.DisplayName = "ThreadpoolQueueLengthOptions.LessThan";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A21);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.LessThan, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "SlidingWindowDuration";
+            context.DisplayName = "ThreadpoolQueueLengthOptions.SlidingWindowDuration";
+            validationResults.Clear();
+            validationAttributes.Clear();
+            validationAttributes.Add(global::__OptionValidationStaticInstances.__Attributes.A8);
+            if (!global::System.ComponentModel.DataAnnotations.Validator.TryValidateValue(options.SlidingWindowDuration, context, validationResults, validationAttributes))
+            {
+                (builder ??= new()).AddResults(validationResults);
+            }
+
+            context.MemberName = "Validate";
+            context.DisplayName = "ThreadpoolQueueLengthOptions.Validate";
+            (builder ??= new()).AddResults(((global::System.ComponentModel.DataAnnotations.IValidatableObject)options).Validate(context));
+
+            return builder is null ? global::Microsoft.Extensions.Options.ValidateOptionsResult.Success : builder.Build();
+        }
+    }
+}
+namespace __OptionValidationStaticInstances
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    file static class __Attributes
+    {
+        internal static readonly global::System.ComponentModel.DataAnnotations.RequiredAttribute A1 = new global::System.ComponentModel.DataAnnotations.RequiredAttribute();
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__MinLengthAttribute A2 = new __OptionValidationGeneratedAttributes.__SourceGen__MinLengthAttribute(
+            (int)1);
+
+        internal static readonly global::Microsoft.Diagnostics.Monitoring.WebApi.Validation.IntegerOrHexStringAttribute A3 = new global::Microsoft.Diagnostics.Monitoring.WebApi.Validation.IntegerOrHexStringAttribute();
+
+        internal static readonly global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute A4 = new global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute(
+            typeof(global::System.Diagnostics.Tracing.EventLevel));
+
+        internal static readonly global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute A5 = new global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute(
+            typeof(global::Microsoft.Diagnostics.Monitoring.WebApi.Models.DumpType));
+
+        internal static readonly global::System.ComponentModel.DataAnnotations.RequiredAttribute A6 = new global::System.ComponentModel.DataAnnotations.RequiredAttribute()
+        {
+            ErrorMessageResourceName = "ErrorMessage_NoDefaultEgressProvider",
+            ErrorMessageResourceType = typeof(global::Microsoft.Diagnostics.Monitoring.WebApi.OptionsDisplayStrings)
+        };
+
+        internal static readonly global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.ValidateEgressProviderAttribute A7 = new global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.ValidateEgressProviderAttribute();
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute A8 = new __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute(
+            typeof(global::System.TimeSpan),
+            "00:00:01",
+            "1.00:00:00");
+
+        internal static readonly global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute A9 = new global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute(
+            typeof(global::Microsoft.Extensions.Logging.LogLevel));
+
+        internal static readonly global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute A10 = new global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute(
+            typeof(global::Microsoft.Diagnostics.Monitoring.Options.LogFormat));
+
+        internal static readonly global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute A11 = new global::System.ComponentModel.DataAnnotations.EnumDataTypeAttribute(
+            typeof(global::Microsoft.Diagnostics.Monitoring.WebApi.Models.TraceProfile));
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute A12 = new __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute(
+            (int)1,
+            (int)1024);
+
+        internal static readonly global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.RequiredGuidAttribute A13 = new global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.Actions.RequiredGuidAttribute();
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute A14 = new __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute(
+            (int)1,
+            (int)2147483647);
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute A15 = new __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute(
+            typeof(global::System.TimeSpan),
+            "00:00:01",
+            "365.00:00:00");
+
+        internal static readonly global::System.ComponentModel.DataAnnotations.RequiredAttribute A16 = new global::System.ComponentModel.DataAnnotations.RequiredAttribute()
+        {
+            ErrorMessageResourceName = "ErrorMessage_NoDefaultRequestCount",
+            ErrorMessageResourceType = typeof(global::Microsoft.Diagnostics.Monitoring.WebApi.OptionsDisplayStrings)
+        };
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute A17 = new __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute(
+            typeof(global::System.TimeSpan),
+            "00:00:00",
+            "01:00:00");
+
+        internal static readonly global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.RegularExpressionsAttribute A18 = new global::Microsoft.Diagnostics.Tools.Monitor.CollectionRules.Options.RegularExpressionsAttribute(
+            "[1-5][0-9]{2}(-[1-5][0-9]{2})?")
+        {
+            ErrorMessageResourceName = "ErrorMessage_StatusCodesRegularExpressionDoesNotMatch",
+            ErrorMessageResourceType = typeof(global::Microsoft.Diagnostics.Monitoring.WebApi.OptionsDisplayStrings)
+        };
+
+        internal static readonly global::System.ComponentModel.DataAnnotations.RequiredAttribute A19 = new global::System.ComponentModel.DataAnnotations.RequiredAttribute()
+        {
+            ErrorMessageResourceName = "ErrorMessage_NoDefaultResponseCount",
+            ErrorMessageResourceType = typeof(global::Microsoft.Diagnostics.Monitoring.WebApi.OptionsDisplayStrings)
+        };
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute A20 = new __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute(
+            (double)0,
+            (double)100);
+
+        internal static readonly __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute A21 = new __OptionValidationGeneratedAttributes.__SourceGen__RangeAttribute(
+            (double)0,
+            (double)1.7976931348623157E+308);
+    }
+}
+namespace __OptionValidationStaticInstances
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    file static class __Validators
+    {
+    }
+}
+namespace __OptionValidationGeneratedAttributes
+{
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    [global::System.AttributeUsage(global::System.AttributeTargets.Property | global::System.AttributeTargets.Field | global::System.AttributeTargets.Parameter, AllowMultiple = false)]
+    file class __SourceGen__MinLengthAttribute : global::System.ComponentModel.DataAnnotations.ValidationAttribute
+    {
+        private static string DefaultErrorMessageString => "The field {0} must be a string or array type with a minimum length of '{1}'.";
+
+        public __SourceGen__MinLengthAttribute(int length) : base(() => DefaultErrorMessageString) { Length = length; }
+        public int Length { get; }
+        public override bool IsValid(object? value)
+        {
+            if (Length < -1)
+            {
+                throw new global::System.InvalidOperationException("MinLengthAttribute must have a Length value that is zero or greater.");
+            }
+            if (value == null)
+            {
+                return true;
+            }
+
+            int length;
+            if (value is string stringValue)
+            {
+                length = stringValue.Length;
+            }
+            else if (value is System.Collections.ICollection collectionValue)
+            {
+                length = collectionValue.Count;
+            }
+            else
+            {
+                throw new global::System.InvalidCastException($"The field of type {value.GetType()} must be a string, array, or ICollection type.");
+            }
+
+            return length >= Length;
+        }
+        public override string FormatErrorMessage(string name) => string.Format(global::System.Globalization.CultureInfo.CurrentCulture, ErrorMessageString, name, Length);
+    }
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Extensions.Options.SourceGeneration", "10.0.12.25812")]
+    [global::System.AttributeUsage(global::System.AttributeTargets.Property | global::System.AttributeTargets.Field | global::System.AttributeTargets.Parameter, AllowMultiple = false)]
+    file class __SourceGen__RangeAttribute : global::System.ComponentModel.DataAnnotations.ValidationAttribute
+    {
+        public __SourceGen__RangeAttribute(int minimum, int maximum) : base()
+        {
+            Minimum = minimum;
+            Maximum = maximum;
+            OperandType = typeof(int);
+        }
+        public __SourceGen__RangeAttribute(double minimum, double maximum) : base()
+        {
+            Minimum = minimum;
+            Maximum = maximum;
+            OperandType = typeof(double);
+        }
+        public __SourceGen__RangeAttribute(global::System.Type type, string minimum, string maximum) : base()
+        {
+            OperandType = type;
+            _needToConvertMinMax = true;
+            Minimum = minimum;
+            Maximum = maximum;
+        }
+        public object Minimum { get; private set; }
+        public object Maximum { get; private set; }
+        public bool MinimumIsExclusive { get; set; }
+        public bool MaximumIsExclusive { get; set; }
+        public global::System.Type OperandType { get; }
+        public bool ParseLimitsInInvariantCulture { get; set; }
+        public bool ConvertValueInInvariantCulture { get; set; }
+        public override string FormatErrorMessage(string name) =>
+                string.Format(global::System.Globalization.CultureInfo.CurrentCulture, GetValidationErrorMessage(), name, Minimum, Maximum);
+        private readonly bool _needToConvertMinMax;
+        private volatile bool _initialized;
+        private readonly object _lock = new();
+        private const string MinMaxError = "The minimum and maximum values must be set to valid values.";
+
+        public override bool IsValid(object? value)
+        {
+            if (!_initialized)
+            {
+                lock (_lock)
+                {
+                    if (!_initialized)
+                    {
+                        if (Minimum is null || Maximum is null)
+                        {
+                            throw new global::System.InvalidOperationException(MinMaxError);
+                        }
+                        if (_needToConvertMinMax)
+                        {
+                            System.Globalization.CultureInfo culture = ParseLimitsInInvariantCulture ? global::System.Globalization.CultureInfo.InvariantCulture : global::System.Globalization.CultureInfo.CurrentCulture;
+                            if (OperandType == typeof(global::System.TimeSpan))
+                            {
+                                if (!global::System.TimeSpan.TryParse((string)Minimum, culture, out global::System.TimeSpan timeSpanMinimum) ||
+                                    !global::System.TimeSpan.TryParse((string)Maximum, culture, out global::System.TimeSpan timeSpanMaximum))
+                                {
+                                    throw new global::System.InvalidOperationException(MinMaxError);
+                                }
+                                Minimum = timeSpanMinimum;
+                                Maximum = timeSpanMaximum;
+                            }
+                            else
+                            {
+                                Minimum = ConvertValue(Minimum, culture) ?? throw new global::System.InvalidOperationException(MinMaxError);
+                                Maximum = ConvertValue(Maximum, culture) ?? throw new global::System.InvalidOperationException(MinMaxError);
+                            }
+                        }
+                        int cmp = ((global::System.IComparable)Minimum).CompareTo((global::System.IComparable)Maximum);
+                        if (cmp > 0)
+                        {
+                            throw new global::System.InvalidOperationException("The maximum value '{Maximum}' must be greater than or equal to the minimum value '{Minimum}'.");
+                        }
+                        else if (cmp == 0 && (MinimumIsExclusive || MaximumIsExclusive))
+                        {
+                            throw new global::System.InvalidOperationException("Cannot use exclusive bounds when the maximum value is equal to the minimum value.");
+                        }
+                        _initialized = true;
+                    }
+                }
+            }
+
+            if (value is null or string { Length: 0 })
+            {
+                return true;
+            }
+
+            System.Globalization.CultureInfo formatProvider = ConvertValueInInvariantCulture ? global::System.Globalization.CultureInfo.InvariantCulture : global::System.Globalization.CultureInfo.CurrentCulture;
+            object? convertedValue;
+
+            if (OperandType == typeof(global::System.TimeSpan))
+            {
+                if (value is global::System.TimeSpan)
+                {
+                    convertedValue = value;
+                }
+                else if (value is string)
+                {
+                    if (!global::System.TimeSpan.TryParse((string)value, formatProvider, out global::System.TimeSpan timeSpanValue))
+                    {
+                        return false;
+                    }
+                    convertedValue = timeSpanValue;
+                }
+                else
+                {
+                    throw new global::System.InvalidOperationException($"A value type {value.GetType()} that is not a TimeSpan or a string has been given. This might indicate a problem with the source generator.");
+                }
+            }
+            else
+            {
+                try
+                {
+                    convertedValue = ConvertValue(value, formatProvider);
+                }
+                catch (global::System.Exception e) when (e is global::System.FormatException or global::System.InvalidCastException or global::System.NotSupportedException)
+                {
+                    return false;
+                }
+            }
+
+            var min = (global::System.IComparable)Minimum;
+            var max = (global::System.IComparable)Maximum;
+
+            return
+                (MinimumIsExclusive ? min.CompareTo(convertedValue) < 0 : min.CompareTo(convertedValue) <= 0) &&
+                (MaximumIsExclusive ? max.CompareTo(convertedValue) > 0 : max.CompareTo(convertedValue) >= 0);
+        }
+        private string GetValidationErrorMessage()
+        {
+            return (MinimumIsExclusive, MaximumIsExclusive) switch
+            {
+                (false, false) => "The field {0} must be between {1} and {2}.",
+                (true, false) => "The field {0} must be between {1} exclusive and {2}.",
+                (false, true) => "The field {0} must be between {1} and {2} exclusive.",
+                (true, true) => "The field {0} must be between {1} exclusive and {2} exclusive.",
+            };
+        }
+        private object? ConvertValue(object? value, System.Globalization.CultureInfo formatProvider)
+        {
+            if (value is string stringValue)
+            {
+                value = global::System.Convert.ChangeType(stringValue, OperandType, formatProvider);
+            }
+            else
+            {
+                value = global::System.Convert.ChangeType(value, OperandType, formatProvider);
+            }
+            return value;
+        }
+    }
+}
diff --git a/src/Tools/dotnet-monitor/dotnet-monitor.csproj b/src/Tools/dotnet-monitor/dotnet-monitor.csproj
index 3d5349372f8..0b06625cfb1 100644
--- a/src/Tools/dotnet-monitor/dotnet-monitor.csproj
+++ b/src/Tools/dotnet-monitor/dotnet-monitor.csproj
@@ -11,6 +11,8 @@
     <Nullable>enable</Nullable>
     <EnableConfigurationBindingGenerator>false</EnableConfigurationBindingGenerator>
     <DisableCompileTimeOpenApiXmlGenerator>true</DisableCompileTimeOpenApiXmlGenerator>
+    <DisableOptionsValidationGenerator>true</DisableOptionsValidationGenerator>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
   </PropertyGroup>
 
   <ItemGroup>
@@ -19,6 +21,7 @@
     <PackageReference Include="Microsoft.Identity.Web" />
     <PackageReference Include="System.CommandLine" />
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" GeneratePathProperty="true" />
+    <PackageReference Include="Microsoft.Extensions.Options" GeneratePathProperty="true" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(DIAGNOSTICS_REPO_ROOT)' == ''">