// <auto-generated/>
#nullable enable
 
namespace Microsoft.Extensions.Diagnostics.ResourceMonitoring
{
    partial class Log
    {
        /// <summary>
        /// Logs "Computed CPU usage with CgroupCpuTime = {cgroupCpuTime}, HostCpuTime = {hostCpuTime}, PreviousCgroupCpuTime = {previousCgroupCpuTime}, PreviousHostCpuTime = {previousHostCpuTime}, CpuPercentage = {cpuPercentage}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void CpuUsageData(this global::Microsoft.Extensions.Logging.ILogger logger, long cgroupCpuTime, long hostCpuTime, long previousCgroupCpuTime, long previousHostCpuTime, double cpuPercentage)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(6);
                state.TagArray[5] = new("{OriginalFormat}", "Computed CPU usage with CgroupCpuTime = {cgroupCpuTime}, HostCpuTime = {hostCpuTime}, PreviousCgroupCpuTime = {previousCgroupCpuTime}, PreviousHostCpuTime = {previousHostCpuTime}, CpuPercentage = {cpuPercentage}.");
                state.TagArray[4] = new("cgroupCpuTime", cgroupCpuTime);
                state.TagArray[3] = new("hostCpuTime", hostCpuTime);
                state.TagArray[2] = new("previousCgroupCpuTime", previousCgroupCpuTime);
                state.TagArray[1] = new("previousHostCpuTime", previousHostCpuTime);
                state.TagArray[0] = new("cpuPercentage", cpuPercentage);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(1, nameof(CpuUsageData)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var cgroupCpuTime = s.TagArray[4].Value;
                        var hostCpuTime = s.TagArray[3].Value;
                        var previousCgroupCpuTime = s.TagArray[2].Value;
                        var previousHostCpuTime = s.TagArray[1].Value;
                        var cpuPercentage = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Computed CPU usage with CgroupCpuTime = {cgroupCpuTime}, HostCpuTime = {hostCpuTime}, PreviousCgroupCpuTime = {previousCgroupCpuTime}, PreviousHostCpuTime = {previousHostCpuTime}, CpuPercentage = {cpuPercentage}.");
                        #else
                        return global::System.FormattableString.Invariant($"Computed CPU usage with CgroupCpuTime = {cgroupCpuTime}, HostCpuTime = {hostCpuTime}, PreviousCgroupCpuTime = {previousCgroupCpuTime}, PreviousHostCpuTime = {previousHostCpuTime}, CpuPercentage = {cpuPercentage}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Computed memory usage with MemoryUsedInBytes = {memoryUsed}, MemoryLimit = {memoryLimit}, MemoryPercentage = {memoryPercentage}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void MemoryPercentageLimit(this global::Microsoft.Extensions.Logging.ILogger logger, ulong memoryUsed, double memoryLimit, double memoryPercentage)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(4);
                state.TagArray[3] = new("{OriginalFormat}", "Computed memory usage with MemoryUsedInBytes = {memoryUsed}, MemoryLimit = {memoryLimit}, MemoryPercentage = {memoryPercentage}.");
                state.TagArray[2] = new("memoryUsed", memoryUsed);
                state.TagArray[1] = new("memoryLimit", memoryLimit);
                state.TagArray[0] = new("memoryPercentage", memoryPercentage);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(2, nameof(MemoryPercentageLimit)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var memoryUsed = s.TagArray[2].Value;
                        var memoryLimit = s.TagArray[1].Value;
                        var memoryPercentage = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Computed memory usage with MemoryUsedInBytes = {memoryUsed}, MemoryLimit = {memoryLimit}, MemoryPercentage = {memoryPercentage}.");
                        #else
                        return global::System.FormattableString.Invariant($"Computed memory usage with MemoryUsedInBytes = {memoryUsed}, MemoryLimit = {memoryLimit}, MemoryPercentage = {memoryPercentage}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "System resources information: CpuLimit = {cpuLimit}, CpuRequest = {cpuRequest}, MemoryLimit = {memoryLimit}, MemoryRequest = {memoryRequest}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void SystemResourcesInfo(this global::Microsoft.Extensions.Logging.ILogger logger, double cpuLimit, double cpuRequest, ulong memoryLimit, ulong memoryRequest)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(5);
                state.TagArray[4] = new("{OriginalFormat}", "System resources information: CpuLimit = {cpuLimit}, CpuRequest = {cpuRequest}, MemoryLimit = {memoryLimit}, MemoryRequest = {memoryRequest}.");
                state.TagArray[3] = new("cpuLimit", cpuLimit);
                state.TagArray[2] = new("cpuRequest", cpuRequest);
                state.TagArray[1] = new("memoryLimit", memoryLimit);
                state.TagArray[0] = new("memoryRequest", memoryRequest);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(3, nameof(SystemResourcesInfo)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var cpuLimit = s.TagArray[3].Value;
                        var cpuRequest = s.TagArray[2].Value;
                        var memoryLimit = s.TagArray[1].Value;
                        var memoryRequest = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"System resources information: CpuLimit = {cpuLimit}, CpuRequest = {cpuRequest}, MemoryLimit = {memoryLimit}, MemoryRequest = {memoryRequest}.");
                        #else
                        return global::System.FormattableString.Invariant($"System resources information: CpuLimit = {cpuLimit}, CpuRequest = {cpuRequest}, MemoryLimit = {memoryLimit}, MemoryRequest = {memoryRequest}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "For CgroupV2, Computed CPU usage with CgroupCpuTime = {cgroupCpuTime}, PreviousCgroupCpuTime = {previousCgroupCpuTime}, ActualElapsedNanoseconds = {actualElapsedNanoseconds}, CpuCores = {cpuCores}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void CpuUsageDataV2(this global::Microsoft.Extensions.Logging.ILogger logger, long cgroupCpuTime, long previousCgroupCpuTime, double actualElapsedNanoseconds, double cpuCores)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(5);
                state.TagArray[4] = new("{OriginalFormat}", "For CgroupV2, Computed CPU usage with CgroupCpuTime = {cgroupCpuTime}, PreviousCgroupCpuTime = {previousCgroupCpuTime}, ActualElapsedNanoseconds = {actualElapsedNanoseconds}, CpuCores = {cpuCores}.");
                state.TagArray[3] = new("cgroupCpuTime", cgroupCpuTime);
                state.TagArray[2] = new("previousCgroupCpuTime", previousCgroupCpuTime);
                state.TagArray[1] = new("actualElapsedNanoseconds", actualElapsedNanoseconds);
                state.TagArray[0] = new("cpuCores", cpuCores);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(4, nameof(CpuUsageDataV2)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var cgroupCpuTime = s.TagArray[3].Value;
                        var previousCgroupCpuTime = s.TagArray[2].Value;
                        var actualElapsedNanoseconds = s.TagArray[1].Value;
                        var cpuCores = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"For CgroupV2, Computed CPU usage with CgroupCpuTime = {cgroupCpuTime}, PreviousCgroupCpuTime = {previousCgroupCpuTime}, ActualElapsedNanoseconds = {actualElapsedNanoseconds}, CpuCores = {cpuCores}.");
                        #else
                        return global::System.FormattableString.Invariant($"For CgroupV2, Computed CPU usage with CgroupCpuTime = {cgroupCpuTime}, PreviousCgroupCpuTime = {previousCgroupCpuTime}, ActualElapsedNanoseconds = {actualElapsedNanoseconds}, CpuCores = {cpuCores}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Error while getting disk stats: Error={errorMessage}" at "Warning" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void HandleDiskStatsException(this global::Microsoft.Extensions.Logging.ILogger logger, string errorMessage)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(2);
                state.TagArray[1] = new("{OriginalFormat}", "Error while getting disk stats: Error={errorMessage}");
                state.TagArray[0] = new("errorMessage", errorMessage);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Warning,
                    new(5, nameof(HandleDiskStatsException)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var errorMessage = s.TagArray[0].Value ?? "(null)";
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Error while getting disk stats: Error={errorMessage}");
                        #else
                        return global::System.FormattableString.Invariant($"Error while getting disk stats: Error={errorMessage}");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Computed memory usage = {memoryUsed}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void MemoryUsageData(this global::Microsoft.Extensions.Logging.ILogger logger, ulong memoryUsed)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(2);
                state.TagArray[1] = new("{OriginalFormat}", "Computed memory usage = {memoryUsed}.");
                state.TagArray[0] = new("memoryUsed", memoryUsed);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(6, nameof(MemoryUsageData)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var memoryUsed = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Computed memory usage = {memoryUsed}.");
                        #else
                        return global::System.FormattableString.Invariant($"Computed memory usage = {memoryUsed}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Computed memory usage with MemoryUsedInBytes = {memoryUsed}, MemoryRequest = {memoryRequest}, MemoryPercentage = {memoryPercentage}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void MemoryPercentageRequest(this global::Microsoft.Extensions.Logging.ILogger logger, ulong memoryUsed, double memoryRequest, double memoryPercentage)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(4);
                state.TagArray[3] = new("{OriginalFormat}", "Computed memory usage with MemoryUsedInBytes = {memoryUsed}, MemoryRequest = {memoryRequest}, MemoryPercentage = {memoryPercentage}.");
                state.TagArray[2] = new("memoryUsed", memoryUsed);
                state.TagArray[1] = new("memoryRequest", memoryRequest);
                state.TagArray[0] = new("memoryPercentage", memoryPercentage);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(7, nameof(MemoryPercentageRequest)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var memoryUsed = s.TagArray[2].Value;
                        var memoryRequest = s.TagArray[1].Value;
                        var memoryPercentage = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Computed memory usage with MemoryUsedInBytes = {memoryUsed}, MemoryRequest = {memoryRequest}, MemoryPercentage = {memoryPercentage}.");
                        #else
                        return global::System.FormattableString.Invariant($"Computed memory usage with MemoryUsedInBytes = {memoryUsed}, MemoryRequest = {memoryRequest}, MemoryPercentage = {memoryPercentage}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
    }
}
 
namespace Microsoft.Extensions.Diagnostics.ResourceMonitoring
{
    partial class Log
    {
        /// <summary>
        /// Logs "Unable to gather utilization statistics." at "Error" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void HandledGatherStatisticsException(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception e)
        {
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(1);
                state.TagArray[0] = new("{OriginalFormat}", "Unable to gather utilization statistics.");
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Error,
                    new(1, nameof(HandledGatherStatisticsException)),
                    state,
                    e,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        return "Unable to gather utilization statistics.";
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Publisher `{Publisher}` was unable to publish utilization statistics." at "Error" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void HandlePublishUtilizationException(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.Exception e, string publisher)
        {
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(2);
                state.TagArray[1] = new("{OriginalFormat}", "Publisher `{Publisher}` was unable to publish utilization statistics.");
                state.TagArray[0] = new("Publisher", publisher);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Error,
                    new(2, nameof(HandlePublishUtilizationException)),
                    state,
                    e,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var publisher = s.TagArray[0].Value ?? "(null)";
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Publisher `{publisher}` was unable to publish utilization statistics.");
                        #else
                        return global::System.FormattableString.Invariant($"Publisher `{publisher}` was unable to publish utilization statistics.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Snapshot received: TotalTimeSinceStart={totalTimeSinceStart}, KernelTimeSinceStart={kernelTimeSinceStart}, UserTimeSinceStart={userTimeSinceStart}, MemoryUsageInBytes={memoryUsageInBytes}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void SnapshotReceived(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.TimeSpan totalTimeSinceStart, global::System.TimeSpan kernelTimeSinceStart, global::System.TimeSpan userTimeSinceStart, ulong memoryUsageInBytes)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(5);
                state.TagArray[4] = new("{OriginalFormat}", "Snapshot received: TotalTimeSinceStart={totalTimeSinceStart}, KernelTimeSinceStart={kernelTimeSinceStart}, UserTimeSinceStart={userTimeSinceStart}, MemoryUsageInBytes={memoryUsageInBytes}.");
                state.TagArray[3] = new("totalTimeSinceStart", totalTimeSinceStart);
                state.TagArray[2] = new("kernelTimeSinceStart", kernelTimeSinceStart);
                state.TagArray[1] = new("userTimeSinceStart", userTimeSinceStart);
                state.TagArray[0] = new("memoryUsageInBytes", memoryUsageInBytes);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(3, nameof(SnapshotReceived)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var totalTimeSinceStart = s.TagArray[3].Value;
                        var kernelTimeSinceStart = s.TagArray[2].Value;
                        var userTimeSinceStart = s.TagArray[1].Value;
                        var memoryUsageInBytes = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Snapshot received: TotalTimeSinceStart={totalTimeSinceStart}, KernelTimeSinceStart={kernelTimeSinceStart}, UserTimeSinceStart={userTimeSinceStart}, MemoryUsageInBytes={memoryUsageInBytes}.");
                        #else
                        return global::System.FormattableString.Invariant($"Snapshot received: TotalTimeSinceStart={totalTimeSinceStart}, KernelTimeSinceStart={kernelTimeSinceStart}, UserTimeSinceStart={userTimeSinceStart}, MemoryUsageInBytes={memoryUsageInBytes}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
    }
}
 
namespace Microsoft.Extensions.Diagnostics.ResourceMonitoring.Windows
{
    partial class Log
    {
        /// <summary>
        /// Logs "Resource Monitoring is running inside a Job Object. For more information about Job Objects see https://aka.ms/job-objects" at "Information" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void RunningInsideJobObject(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(1);
                state.TagArray[0] = new("{OriginalFormat}", "Resource Monitoring is running inside a Job Object. For more information about Job Objects see https://aka.ms/job-objects");
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Information,
                    new(1, nameof(RunningInsideJobObject)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        return "Resource Monitoring is running inside a Job Object. For more information about Job Objects see https://aka.ms/job-objects";
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Resource Monitoring is running outside of Job Object. For more information about Job Objects see https://aka.ms/job-objects" at "Information" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void RunningOutsideJobObject(this global::Microsoft.Extensions.Logging.ILogger logger)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(1);
                state.TagArray[0] = new("{OriginalFormat}", "Resource Monitoring is running outside of Job Object. For more information about Job Objects see https://aka.ms/job-objects");
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Information,
                    new(2, nameof(RunningOutsideJobObject)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        return "Resource Monitoring is running outside of Job Object. For more information about Job Objects see https://aka.ms/job-objects";
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Computed CPU usage with CpuUsageTicks = {cpuUsageTicks}, OldCpuUsageTicks = {oldCpuUsageTicks}, TimeTickDelta = {timeTickDelta}, CpuUnits = {cpuUnits}, CpuPercentage = {cpuPercentage}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void CpuUsageData(this global::Microsoft.Extensions.Logging.ILogger logger, long cpuUsageTicks, long oldCpuUsageTicks, double timeTickDelta, double cpuUnits, double cpuPercentage)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(6);
                state.TagArray[5] = new("{OriginalFormat}", "Computed CPU usage with CpuUsageTicks = {cpuUsageTicks}, OldCpuUsageTicks = {oldCpuUsageTicks}, TimeTickDelta = {timeTickDelta}, CpuUnits = {cpuUnits}, CpuPercentage = {cpuPercentage}.");
                state.TagArray[4] = new("cpuUsageTicks", cpuUsageTicks);
                state.TagArray[3] = new("oldCpuUsageTicks", oldCpuUsageTicks);
                state.TagArray[2] = new("timeTickDelta", timeTickDelta);
                state.TagArray[1] = new("cpuUnits", cpuUnits);
                state.TagArray[0] = new("cpuPercentage", cpuPercentage);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(3, nameof(CpuUsageData)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var cpuUsageTicks = s.TagArray[4].Value;
                        var oldCpuUsageTicks = s.TagArray[3].Value;
                        var timeTickDelta = s.TagArray[2].Value;
                        var cpuUnits = s.TagArray[1].Value;
                        var cpuPercentage = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Computed CPU usage with CpuUsageTicks = {cpuUsageTicks}, OldCpuUsageTicks = {oldCpuUsageTicks}, TimeTickDelta = {timeTickDelta}, CpuUnits = {cpuUnits}, CpuPercentage = {cpuPercentage}.");
                        #else
                        return global::System.FormattableString.Invariant($"Computed CPU usage with CpuUsageTicks = {cpuUsageTicks}, OldCpuUsageTicks = {oldCpuUsageTicks}, TimeTickDelta = {timeTickDelta}, CpuUnits = {cpuUnits}, CpuPercentage = {cpuPercentage}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Computed memory usage for container: CurrentMemoryUsage = {currentMemoryUsage}, LimitMemory = {limitMemory}, RequestMemory = {requestMemory}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void ContainerMemoryUsageData(this global::Microsoft.Extensions.Logging.ILogger logger, ulong currentMemoryUsage, double limitMemory, double requestMemory)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(4);
                state.TagArray[3] = new("{OriginalFormat}", "Computed memory usage for container: CurrentMemoryUsage = {currentMemoryUsage}, LimitMemory = {limitMemory}, RequestMemory = {requestMemory}.");
                state.TagArray[2] = new("currentMemoryUsage", currentMemoryUsage);
                state.TagArray[1] = new("limitMemory", limitMemory);
                state.TagArray[0] = new("requestMemory", requestMemory);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(4, nameof(ContainerMemoryUsageData)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var currentMemoryUsage = s.TagArray[2].Value;
                        var limitMemory = s.TagArray[1].Value;
                        var requestMemory = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Computed memory usage for container: CurrentMemoryUsage = {currentMemoryUsage}, LimitMemory = {limitMemory}, RequestMemory = {requestMemory}.");
                        #else
                        return global::System.FormattableString.Invariant($"Computed memory usage for container: CurrentMemoryUsage = {currentMemoryUsage}, LimitMemory = {limitMemory}, RequestMemory = {requestMemory}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Computed CPU usage with CpuUsageKernelTicks = {cpuUsageKernelTicks}, CpuUsageUserTicks = {cpuUsageUserTicks}, OldCpuUsageTicks = {oldCpuUsageTicks}, TimeTickDelta = {timeTickDelta}, CpuUnits = {cpuUnits}, CpuPercentage = {cpuPercentage}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void CpuContainerUsageData(this global::Microsoft.Extensions.Logging.ILogger logger, long cpuUsageKernelTicks, long cpuUsageUserTicks, long oldCpuUsageTicks, double timeTickDelta, double cpuUnits, double cpuPercentage)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(7);
                state.TagArray[6] = new("{OriginalFormat}", "Computed CPU usage with CpuUsageKernelTicks = {cpuUsageKernelTicks}, CpuUsageUserTicks = {cpuUsageUserTicks}, OldCpuUsageTicks = {oldCpuUsageTicks}, TimeTickDelta = {timeTickDelta}, CpuUnits = {cpuUnits}, CpuPercentage = {cpuPercentage}.");
                state.TagArray[5] = new("cpuUsageKernelTicks", cpuUsageKernelTicks);
                state.TagArray[4] = new("cpuUsageUserTicks", cpuUsageUserTicks);
                state.TagArray[3] = new("oldCpuUsageTicks", oldCpuUsageTicks);
                state.TagArray[2] = new("timeTickDelta", timeTickDelta);
                state.TagArray[1] = new("cpuUnits", cpuUnits);
                state.TagArray[0] = new("cpuPercentage", cpuPercentage);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(5, nameof(CpuContainerUsageData)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var cpuUsageKernelTicks = s.TagArray[5].Value;
                        var cpuUsageUserTicks = s.TagArray[4].Value;
                        var oldCpuUsageTicks = s.TagArray[3].Value;
                        var timeTickDelta = s.TagArray[2].Value;
                        var cpuUnits = s.TagArray[1].Value;
                        var cpuPercentage = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Computed CPU usage with CpuUsageKernelTicks = {cpuUsageKernelTicks}, CpuUsageUserTicks = {cpuUsageUserTicks}, OldCpuUsageTicks = {oldCpuUsageTicks}, TimeTickDelta = {timeTickDelta}, CpuUnits = {cpuUnits}, CpuPercentage = {cpuPercentage}.");
                        #else
                        return global::System.FormattableString.Invariant($"Computed CPU usage with CpuUsageKernelTicks = {cpuUsageKernelTicks}, CpuUsageUserTicks = {cpuUsageUserTicks}, OldCpuUsageTicks = {oldCpuUsageTicks}, TimeTickDelta = {timeTickDelta}, CpuUnits = {cpuUnits}, CpuPercentage = {cpuPercentage}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "System resources information: CpuLimit = {cpuLimit}, CpuRequest = {cpuRequest}, MemoryLimit = {memoryLimit}, MemoryRequest = {memoryRequest}." at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void SystemResourcesInfo(this global::Microsoft.Extensions.Logging.ILogger logger, double cpuLimit, double cpuRequest, ulong memoryLimit, ulong memoryRequest)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(5);
                state.TagArray[4] = new("{OriginalFormat}", "System resources information: CpuLimit = {cpuLimit}, CpuRequest = {cpuRequest}, MemoryLimit = {memoryLimit}, MemoryRequest = {memoryRequest}.");
                state.TagArray[3] = new("cpuLimit", cpuLimit);
                state.TagArray[2] = new("cpuRequest", cpuRequest);
                state.TagArray[1] = new("memoryLimit", memoryLimit);
                state.TagArray[0] = new("memoryRequest", memoryRequest);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(6, nameof(SystemResourcesInfo)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var cpuLimit = s.TagArray[3].Value;
                        var cpuRequest = s.TagArray[2].Value;
                        var memoryLimit = s.TagArray[1].Value;
                        var memoryRequest = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"System resources information: CpuLimit = {cpuLimit}, CpuRequest = {cpuRequest}, MemoryLimit = {memoryLimit}, MemoryRequest = {memoryRequest}.");
                        #else
                        return global::System.FormattableString.Invariant($"System resources information: CpuLimit = {cpuLimit}, CpuRequest = {cpuRequest}, MemoryLimit = {memoryLimit}, MemoryRequest = {memoryRequest}.");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Error initializing disk io perf counter: PerfCounter={counterName}, Error={errorMessage}" at "Warning" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void DiskIoPerfCounterException(this global::Microsoft.Extensions.Logging.ILogger logger, string counterName, string errorMessage)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Warning))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(3);
                state.TagArray[2] = new("{OriginalFormat}", "Error initializing disk io perf counter: PerfCounter={counterName}, Error={errorMessage}");
                state.TagArray[1] = new("counterName", counterName);
                state.TagArray[0] = new("errorMessage", errorMessage);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Warning,
                    new(7, nameof(DiskIoPerfCounterException)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var counterName = s.TagArray[1].Value ?? "(null)";
                        var errorMessage = s.TagArray[0].Value ?? "(null)";
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Error initializing disk io perf counter: PerfCounter={counterName}, Error={errorMessage}");
                        #else
                        return global::System.FormattableString.Invariant($"Error initializing disk io perf counter: PerfCounter={counterName}, Error={errorMessage}");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
 
        /// <summary>
        /// Logs "Computed memory usage for current process: ProcessMemoryUsage = {processMemoryUsage}, TotalMemory = {totalMemory}, MemoryPercentage = {memoryPercentage}" at "Debug" level.
        /// </summary>
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")]
        public static partial void ProcessMemoryPercentageData(this global::Microsoft.Extensions.Logging.ILogger logger, ulong processMemoryUsage, double totalMemory, double memoryPercentage)
        {
            if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
            {
                return;
            }
 
            var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;
            try
            {
 
                _ = state.ReserveTagSpace(4);
                state.TagArray[3] = new("{OriginalFormat}", "Computed memory usage for current process: ProcessMemoryUsage = {processMemoryUsage}, TotalMemory = {totalMemory}, MemoryPercentage = {memoryPercentage}");
                state.TagArray[2] = new("processMemoryUsage", processMemoryUsage);
                state.TagArray[1] = new("totalMemory", totalMemory);
                state.TagArray[0] = new("memoryPercentage", memoryPercentage);
 
                logger.Log(
                    global::Microsoft.Extensions.Logging.LogLevel.Debug,
                    new(8, nameof(ProcessMemoryPercentageData)),
                    state,
                    null,
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "10.9.0.0")] static string (s, _) =>
                    {
                        var processMemoryUsage = s.TagArray[2].Value;
                        var totalMemory = s.TagArray[1].Value;
                        var memoryPercentage = s.TagArray[0].Value;
                        #if NET
                        return string.Create(global::System.Globalization.CultureInfo.InvariantCulture, $"Computed memory usage for current process: ProcessMemoryUsage = {processMemoryUsage}, TotalMemory = {totalMemory}, MemoryPercentage = {memoryPercentage}");
                        #else
                        return global::System.FormattableString.Invariant($"Computed memory usage for current process: ProcessMemoryUsage = {processMemoryUsage}, TotalMemory = {totalMemory}, MemoryPercentage = {memoryPercentage}");
                        #endif
                    });
            }
            finally
            {
                state.Clear();
            }
        }
    }
}