LogLevel

NuGet\NuGetLogger.cs (13)

4using NuGetLogLevel = NuGet.Common.LogLevel; 15public void Log(NuGetLogLevel level, string data) 17if (!verbose && level < NuGetLogLevel.Warning) 24NuGetLogLevel.Error => "ERROR: ", 25NuGetLogLevel.Warning => "WARNING: ", 34public Task LogAsync(NuGetLogLevel level, string data) { Log(level, data); return Task.CompletedTask; } 36public void LogDebug(string data) => Log(NuGetLogLevel.Debug, data); 37public void LogError(string data) => Log(NuGetLogLevel.Error, data); 38public void LogInformation(string data) => Log(NuGetLogLevel.Information, data); 39public void LogInformationSummary(string data) => Log(NuGetLogLevel.Information, data); 40public void LogMinimal(string data) => Log(NuGetLogLevel.Minimal, data); 41public void LogVerbose(string data) => Log(NuGetLogLevel.Verbose, data); 42public void LogWarning(string data) => Log(NuGetLogLevel.Warning, data);

Commands\Pack\PackCommand.cs (6)

78private static LogLevel MappingVerbosityToNugetLogLevel(VerbosityOptions? verbosity) 82VerbosityOptions.diagnostic or VerbosityOptions.diag => LogLevel.Debug, 83VerbosityOptions.minimal or VerbosityOptions.m => LogLevel.Minimal, 84VerbosityOptions.normal or VerbosityOptions.n => LogLevel.Information, 85VerbosityOptions.detailed or VerbosityOptions.d => LogLevel.Verbose, 86_ => LogLevel.Minimal

NugetPackageDownloader\NuGetConsoleLogger.cs (14)

13public void Log(LogLevel level, string data) 17case LogLevel.Debug: 20case LogLevel.Error: 23case LogLevel.Information: 26case LogLevel.Minimal: 29case LogLevel.Verbose: 32case LogLevel.Warning: 43public Task LogAsync(LogLevel level, string data) 89private static LogLevel MappingVerbosityToNugetLogLevel(VerbosityOptions verbosity) 93VerbosityOptions.diagnostic or VerbosityOptions.diag => LogLevel.Debug, 94VerbosityOptions.minimal or VerbosityOptions.m => LogLevel.Minimal, 95VerbosityOptions.normal or VerbosityOptions.n => LogLevel.Information, 96VerbosityOptions.detailed or VerbosityOptions.d => LogLevel.Verbose, 97_ => LogLevel.Information

DebugLogger.cs (5)

38private void LogMessage(string message, NuGet.Common.LogLevel level, bool logToUI = false) 46if (level == NuGet.Common.LogLevel.Error) 50else if (level == NuGet.Common.LogLevel.Warning) 138Task NuGet.Common.ILogger.LogAsync(NuGet.Common.LogLevel level, string data) 143void NuGet.Common.ILogger.Log(NuGet.Common.LogLevel level, string data)

NuGetSdkLogger.cs (23)

55/// <inheritdoc cref="ILogger.Log(NuGet.Common.LogLevel, string)" /> 56public void Log(LogLevel level, string data) 60case LogLevel.Debug: 61case LogLevel.Verbose: 66case LogLevel.Information: 71case LogLevel.Minimal: 76case LogLevel.Warning: 80case LogLevel.Error: 89case LogLevel.Debug: 90case LogLevel.Verbose: 93case LogLevel.Information: 96case LogLevel.Minimal: 99case LogLevel.Warning: 102case LogLevel.Error: 112/// <inheritdoc cref="ILogger.LogAsync(NuGet.Common.LogLevel, string)" /> 113public Task LogAsync(LogLevel level, string data) 129public void LogDebug(string data) => Log(LogLevel.Debug, data); 132public void LogError(string data) => Log(LogLevel.Error, data); 135public void LogInformation(string data) => Log(LogLevel.Information, data); 138public void LogInformationSummary(string data) => Log(LogLevel.Information, data); 141public void LogMinimal(string data) => Log(LogLevel.Minimal, data); 144public void LogVerbose(string data) => Log(LogLevel.Verbose, data); 147public void LogWarning(string data) => Log(LogLevel.Warning, data);

NuGetUtility.cs (4)

49logger.Log(LogLevel.Error, "Encountered Connection Issue: " + e.ToString() + ", retries exhausted"); 52logger.Log(LogLevel.Information, "Encountered Connection Issue: " + e.ToString() + ", retrying..."); 118public void Log(LogLevel level, string data) => _log.LogMessage($"{level.ToString()} - {data}"); 122public Task LogAsync(LogLevel level, string data) => Task.Run(() => Log(level, data));

LockFileCache.cs (2)

117if (message.Level == LogLevel.Error) 125level: message.Level == LogLevel.Warning ? MessageLevel.Warning : MessageLevel.NormalImportance,

ResolvePackageAssets.cs (15)

429case nameof(LogLevel.Error): 431case nameof(LogLevel.Warning): 1254static string GetSeverity(LogLevel level) 1258case LogLevel.Warning: return nameof(LogLevel.Warning); 1259case LogLevel.Error: return nameof(LogLevel.Error); 1291WriteMetadata(MetadataKeys.Severity, nameof(LogLevel.Error)); 1350WriteMetadata(MetadataKeys.Severity, nameof(LogLevel.Error)); 1496if (diagnosticLevels?.TryGetValue(package.Name, out LogLevel level) ?? false) 1527Dictionary<string, LogLevel> GetPackageDiagnosticLevels() 1535var result = new Dictionary<string, LogLevel>(); 1597void ApplyDiagnosticLevel(string package, LogLevel messageLevel, Dictionary<string, LogLevel> diagnosticLevels, Dictionary<string, HashSet<string>> reverseDependencies) 1605if (diagnosticLevels.TryGetValue(package, out LogLevel cachedLevel))

ResolvePackageDependencies.cs (1)

245LogLevel? logLevel = null;

NuGet\CliNuGetLogger.cs (8)

11public void Log(LogLevel level, string data) 15case LogLevel.Debug: LogDebug(data); break; 16case LogLevel.Error: LogError(data); break; 17case LogLevel.Information: LogInformation(data); break; 18case LogLevel.Minimal: LogMinimal(data); break; 19case LogLevel.Verbose: LogVerbose(data); break; 20case LogLevel.Warning: LogWarning(data); break; 29public Task LogAsync(LogLevel level, string data)

Installers\NuGet\NuGetLogger.cs (9)

7using NuGetLogLevel = global::NuGet.Common.LogLevel; 23public void Log(NuGetLogLevel level, string data) 27case NuGetLogLevel.Debug: LogDebug(data); break; 28case NuGetLogLevel.Error: LogError(data); break; 29case NuGetLogLevel.Information: LogInformation(data); break; 30case NuGetLogLevel.Minimal: LogMinimal(data); break; 31case NuGetLogLevel.Verbose: LogVerbose(data); break; 32case NuGetLogLevel.Warning: LogWarning(data); break; 41public Task LogAsync(NuGetLogLevel level, string data)

CheckForDuplicateNuGetItemsTask.cs (1)

61LogLevel.Warning,

Common\MSBuildLogger.cs (12)

94case LogLevel.Error: 98case LogLevel.Warning: 102case LogLevel.Minimal: 106case LogLevel.Information: 110case LogLevel.Debug: 111case LogLevel.Verbose: 126case LogLevel.Error: 130case LogLevel.Warning: 134case LogLevel.Minimal: 138case LogLevel.Information: 142case LogLevel.Debug: 143case LogLevel.Verbose:

src\nuget-client\src\NuGet.Core\NuGet.Build.Tasks\Common\MSBuildLogger.cs (12)

94case LogLevel.Error: 98case LogLevel.Warning: 102case LogLevel.Minimal: 106case LogLevel.Information: 110case LogLevel.Debug: 111case LogLevel.Verbose: 126case LogLevel.Error: 130case LogLevel.Warning: 134case LogLevel.Minimal: 138case LogLevel.Information: 142case LogLevel.Debug: 143case LogLevel.Verbose:

Commands\CommonOptions.cs (11)

23internal static LogLevel ToLogLevel(this VerbosityEnum verbosity) 27VerbosityEnum.q => LogLevel.Warning, 28VerbosityEnum.quiet => LogLevel.Warning, 29VerbosityEnum.m => LogLevel.Minimal, 30VerbosityEnum.minimal => LogLevel.Minimal, 31VerbosityEnum.n => LogLevel.Information, 32VerbosityEnum.normal => LogLevel.Information, 33VerbosityEnum.d => LogLevel.Verbose, 34VerbosityEnum.detailed => LogLevel.Verbose, 35VerbosityEnum.diag => LogLevel.Debug, 36VerbosityEnum.diagnostic => LogLevel.Debug,

Commands\Package\Download\PackageDownloadArgs.cs (1)

20public LogLevel LogLevel { get; set; }

Commands\Package\Update\PackageUpdateArgs.cs (1)

19public required LogLevel LogLevel { get; init; }

Commands\Package\Update\PackageUpdateCommand.cs (1)

55LogLevel logLevel = verbosity.ToLogLevel();

Commands\Package\Update\PackageUpdateCommandRunner.cs (1)

173Information = LogLevel.Verbose,

Commands\Package\Update\PackageUpdateIO.cs (2)

143Information = LogLevel.Verbose, 144Minimal = LogLevel.Verbose,

Commands\PackageReferenceCommands\ListPackage\ListPackageCommand.cs (1)

26Action<LogLevel> setLogLevel,

Commands\Signing\SignCommand.cs (1)

24Action<LogLevel> setLogLevel,

Commands\Signing\TrustedSignersCommand.cs (2)

22Action<LogLevel> setLogLevel) 242Action<LogLevel> setLogLevel,

Commands\Signing\VerifyCommand.cs (1)

22Action<LogLevel> setLogLevel,

Program.cs (2)

46var log = new CommandOutputLogger(LogLevel.Information); 314Action<LogLevel> setLogLevel = (logLevel) => log.VerbosityLevel = logLevel;

Utility\CommandOutputLogger.cs (17)

Utility\RemappedLevelLogger.cs (20)

22private LogLevel GetMappedLevel(LogLevel level) 26LogLevel.Debug => _mapping.Debug, 27LogLevel.Verbose => _mapping.Verbose, 28LogLevel.Information => _mapping.Information, 29LogLevel.Minimal => _mapping.Minimal, 30LogLevel.Warning => _mapping.Warning, 31LogLevel.Error => _mapping.Error, 50public LogLevel Debug { get; init; } = LogLevel.Debug; 51public LogLevel Verbose { get; init; } = LogLevel.Verbose; 52public LogLevel Information { get; init; } = LogLevel.Information; 53public LogLevel Minimal { get; init; } = LogLevel.Minimal; 54public LogLevel Warning { get; init; } = LogLevel.Warning; 55public LogLevel Error { get; init; } = LogLevel.Error;

Utility\XPlatUtility.cs (6)

21/// user. In other words, the default case should only be hit with <c>m</c> or <c>minimal</c> but we use <see cref="Common.LogLevel.Minimal"/> 24public static LogLevel MSBuildVerbosityToNuGetLogLevel(string verbosity) 30return LogLevel.Warning; 33return LogLevel.Information; 38return LogLevel.Debug; 40return LogLevel.Minimal;

ClientCertificatesCommand\ListClientCertRunner.cs (1)

97clientCertificatesLogs.Add(new LogMessage(LogLevel.Information, builder.ToString()));

CommandArgs\PackArgs.cs (1)

28public LogLevel LogLevel { get; set; }

CommandRunners\PackCommandRunner.cs (7)

137if (_packArgs.LogLevel == LogLevel.Verbose) 149if (collectorLogger.Errors.Any(e => e.Level == LogLevel.Error)) 168LogLevel.Minimal)); 177LogLevel.Minimal)); 203LogLevel.Minimal)); 255LogLevel.Minimal)); 983LogLevel.Information));

PackCollectorLogger.cs (1)

82if (message.Level == LogLevel.Warning)

PackCommand\Logging\PackageSpecificWarningProperties.cs (1)

110if (message.Level == LogLevel.Warning &&

RestoreCommand\Logging\RestoreCollectorLogger.cs (7)

94public RestoreCollectorLogger(ILogger innerLogger, LogLevel verbosity, bool hideWarningsAndErrors) 110: this(innerLogger, LogLevel.Debug, hideWarningsAndErrors) 120public RestoreCollectorLogger(ILogger innerLogger, LogLevel verbosity) 131: this(innerLogger, LogLevel.Debug, hideWarningsAndErrors: false) 214if (message.Level == LogLevel.Error || message.Level == LogLevel.Warning) 232if (message.Level == LogLevel.Warning)

RestoreCommand\Logging\WarningPropertiesCollection.cs (4)

99if (message.Level == LogLevel.Warning && 142if (message.Level == LogLevel.Warning && warningProperties != null) 166if (message.Level == LogLevel.Warning && warningProperties != null) 174message.Level = LogLevel.Error;

RestoreCommand\ProjectRestoreCommand.cs (1)

296await _logger.LogAsync(LogLevel.Verbose, string.Format(CultureInfo.CurrentCulture, Strings.Log_ResolvingConflicts, name));

RestoreCommand\RequestFactory\DependencyGraphSpecRequestProvider.cs (1)

75foreach (var projectPath in restoreContext.AdditionalMessages.Where(m => m.Level == Common.LogLevel.Error).Select(m => m.ProjectPath))

RestoreCommand\RestoreCommand.cs (8)

241bool success = !_request.AdditionalMessages?.Any(m => m.Level == LogLevel.Error) ?? true; 550if (message.Level == LogLevel.Error) 719success &= !logs.Any(l => l.Level == LogLevel.Error); 731var errorCodes = ConcatAsString(new HashSet<NuGetLogCode>(logs.Where(l => l.Level == LogLevel.Error).Select(l => l.Code))); 732var warningCodes = ConcatAsString(new HashSet<NuGetLogCode>(logs.Where(l => l.Level == LogLevel.Warning).Select(l => l.Code))); 1778await logger.LogAsync(LogLevel.Verbose, string.Format(CultureInfo.CurrentCulture, Strings.Log_PackagesAndProjectsAreCompatible, graph.TargetGraphName)); 1789await logger.LogAsync(LogLevel.Debug, $"Incompatible projects: {projectCount}"); 1794await logger.LogAsync(LogLevel.Debug, $"Incompatible packages: {packageCount}");

RestoreCommand\RestoreRunner.cs (2)

311result is NoOpRestoreResult ? LogLevel.Information : LogLevel.Minimal,

RestoreCommand\RestoreSummary.cs (1)

206.Where(m => m.Level == LogLevel.Error)

RestoreCommand\Utility\MSBuildRestoreUtility.cs (1)

428var message = new RestoreLogMessage(LogLevel.Information, text);

RestoreCommand\Utility\SpecValidationUtility.cs (1)

162logger.Log(new RestoreLogMessage(LogLevel.Error, NuGetLogCode.NU1105, message) { FilePath = spec.FilePath, ProjectPath = spec.FilePath });

TrustedSignersCommand\TrustedSignerActionsProvider.cs (5)

63await _logger.LogAsync(LogLevel.Minimal, string.Format(CultureInfo.CurrentCulture, Strings.SuccessfullySynchronizedTrustedRepository, name)); 139await _logger.LogAsync(LogLevel.Minimal, string.Format(CultureInfo.CurrentCulture, Strings.SuccessfullyAddedTrustedRepository, name)); 152await _logger.LogAsync(LogLevel.Minimal, string.Format(CultureInfo.CurrentCulture, Strings.SuccessfullyAddedTrustedAuthor, name)); 210_logger.Log(LogLevel.Minimal, string.Format(CultureInfo.CurrentCulture, logMessage, name)); 239await _logger.LogAsync(LogLevel.Minimal, string.Format(CultureInfo.CurrentCulture, Strings.SuccessfullyAddedTrustedRepository, name));

TrustedSignersCommand\TrustedSignersCommandRunner.cs (6)

207await logger.LogAsync(LogLevel.Minimal, Strings.NoTrustedSigners); 213await logger.LogAsync(LogLevel.Minimal, Strings.RegsiteredTrustedSigners); 214await logger.LogAsync(LogLevel.Minimal, Environment.NewLine); 247trustedSignersLogs.Add(new LogMessage(LogLevel.Minimal, trustedSignerBuilder.ToString())); 258await logger.LogAsync(LogLevel.Minimal, string.Format(CultureInfo.CurrentCulture, Strings.NoTrustedSignersMatching, name)); 264await logger.LogAsync(LogLevel.Minimal, string.Format(CultureInfo.CurrentCulture, Strings.SuccessfullyRemovedTrustedSigner, name));

VerifyCommand\VerifyArgs.cs (1)

42public LogLevel LogLevel { get; set; }

VerifyCommand\VerifyCommandRunner.cs (4)

133await logger.LogMessagesAsync(logMessages.Where(m => m.Level < LogLevel.Warning)); 135if (logMessages.Any(m => m.Level >= LogLevel.Warning)) 139IEnumerable<SignatureLog> warnsanderrors = logMessages.Where(m => m.Level >= LogLevel.Warning); 141var errors = warnsanderrors.Count(m => m.Level == LogLevel.Error);

Errors\ILogMessage.cs (1)

13LogLevel Level { get; set; }

Errors\LogMessage.cs (6)

13public LogLevel Level { get; set; } 20public LogMessage(LogLevel level, string message, NuGetLogCode code) 26public LogMessage(LogLevel level, string message) 39return new LogMessage(LogLevel.Error, message, code); 44return new LogMessage(LogLevel.Warning, message, code); 47public static LogMessage Create(LogLevel level, string message)

Errors\PackagingLogMessage.cs (8)

11public LogLevel Level { get; set; } 31private PackagingLogMessage(LogLevel logLevel, NuGetLogCode logCode, string message) 42private PackagingLogMessage(LogLevel logLevel, NuGetLogCode logCode, string message, string? libraryId, NuGetFramework? framework) 52private PackagingLogMessage(LogLevel logLevel, string message) 62return new PackagingLogMessage(LogLevel.Error, code, message); 67return new PackagingLogMessage(LogLevel.Warning, code, message); 70public static PackagingLogMessage CreateMessage(string message, LogLevel logLevel) 77return new PackagingLogMessage(logLevel: LogLevel.Warning, logCode: code, message: message, libraryId: libraryId, framework: framework);

Errors\RestoreLogMessage.cs (12)

ExceptionUtilities.cs (4)

46logger.Log(new LogMessage(LogLevel.Error, DisplayMessage(unwrappedException))); 50var stackLevel = (logStackAsError || ExceptionLogger.Instance.ShowStack) ? LogLevel.Error : LogLevel.Verbose;

Logging\ILogger.cs (2)

28void Log(LogLevel level, string data); 30Task LogAsync(LogLevel level, string data);

Logging\LegacyLoggerAdapter.cs (8)

15public void Log(LogLevel level, string data) 19case LogLevel.Debug: 25case LogLevel.Error: 31case LogLevel.Information: 37case LogLevel.Minimal: 43case LogLevel.Verbose: 49case LogLevel.Warning: 57public Task LogAsync(LogLevel level, string data)

Logging\LoggerBase.cs (15)

10public LogLevel VerbosityLevel { get; set; } = LogLevel.Debug; 16public LoggerBase(LogLevel verbosityLevel) 25public virtual void Log(LogLevel level, string data) 33public virtual Task LogAsync(LogLevel level, string data) 45Log(LogLevel.Debug, data); 50Log(LogLevel.Error, data); 55Log(LogLevel.Information, data); 60Log(LogLevel.Information, data); 65Log(LogLevel.Minimal, data); 70Log(LogLevel.Verbose, data); 75Log(LogLevel.Warning, data); 81protected virtual bool DisplayMessage(LogLevel messageLevel) 89protected virtual bool CollectMessage(LogLevel messageLevel) 91return (messageLevel >= LogLevel.Warning);

Logging\NullLogger.cs (2)

27public override void Log(LogLevel level, string data) { } 31public override Task LogAsync(LogLevel level, string data) { return Task.CompletedTask; }

SecurePluginCredentialProvider.cs (1)

154var logLevel = LogRequestHandler.GetLogLevel(logger);

IDE\PackageRestoreManager.cs (1)

393packageRestoreContext.Logger.Log(LogLevel.Error, string.Format(CultureInfo.CurrentCulture, Strings.Error_HttpSource_Single, "restore", source.Source));

MessageLevelExtensions.cs (7)

11/// <summary> Convert <see cref="MessageLevel"/> to <see cref="LogLevel"/>. </summary> 14public static LogLevel ToLogLevel(this MessageLevel messageLevel) 18case MessageLevel.Error: return LogLevel.Error; 19case MessageLevel.Warning: return LogLevel.Warning; 20case MessageLevel.Info: return LogLevel.Information; 21case MessageLevel.Debug: return LogLevel.Debug; 22default: return LogLevel.Minimal;

NuGetPackageManager.cs (2)

3496.Where(e => e.Level == LogLevel.Error || e.Level == LogLevel.Warning)

Utility\LogUtility.cs (5)

12public static MessageLevel LogLevelToMessageLevel(LogLevel level) 16case LogLevel.Error: 19case LogLevel.Warning: 22case LogLevel.Information: 23case LogLevel.Minimal:

PackageExtractor.cs (2)

1123if (collectorLogger.Errors.Any(e => e.Level >= LogLevel.Error)) 1156LogLevel.Verbose,

Rules\BestPractice\MissingReadmeRule.cs (1)

32LogLevel.Minimal);

Signing\SignatureLog.cs (10)

15public LogLevel Level { get; set; } 29private SignatureLog(LogLevel level, NuGetLogCode code, string message) 40return new SignatureLog(LogLevel.Minimal, NuGetLogCode.Undefined, message); 46return new SignatureLog(LogLevel.Information, NuGetLogCode.Undefined, message); 52return new SignatureLog(LogLevel.Verbose, NuGetLogCode.Undefined, message); 58return new SignatureLog(LogLevel.Debug, NuGetLogCode.Undefined, message); 64var level = fatal ? LogLevel.Error : LogLevel.Warning; 71return new SignatureLog(LogLevel.Error, code, message);

Signing\TrustedSigners\TrustedSignersProvider.cs (1)

104logger.Log(new LogMessage(LogLevel.Warning,

Signing\TrustStore\CertificateBundleX509ChainFactory.cs (1)

111logMessage = new LogMessage(LogLevel.Warning, message, NuGetLogCode.NU3042);

Signing\Verification\PackageVerificationResult.cs (2)

37return Issues.Where(p => p.Level == LogLevel.Warning); 42return Issues.Where(p => p.Level == LogLevel.Error);

_generated\1\CacheFileSourceGen.LogLevel.g.cs (9)

_generated\12\CacheFileSourceGen.GetJsonTypeInfo.g.cs (1)

28if (type == typeof(global::NuGet.Common.LogLevel))

_generated\14\AssetsLogMessageSourceGen.LogLevel.g.cs (9)

_generated\18\AssetsLogMessageSourceGen.AssetsLogMessage.g.cs (9)

_generated\23\AssetsLogMessageSourceGen.GetJsonTypeInfo.g.cs (1)

24if (type == typeof(global::NuGet.Common.LogLevel))

_generated\5\CacheFileSourceGen.IAssetsLogMessage.g.cs (3)

53var info0 = new global::System.Text.Json.Serialization.Metadata.JsonPropertyInfoValues<global::NuGet.Common.LogLevel> 68AttributeProviderFactory = static () => typeof(global::NuGet.ProjectModel.IAssetsLogMessage).GetProperty("Level", InstanceMemberBindingFlags, null, typeof(global::NuGet.Common.LogLevel), global::System.Array.Empty<global::System.Type>(), null), 71properties[0] = global::System.Text.Json.Serialization.Metadata.JsonMetadataServices.CreatePropertyInfo<global::NuGet.Common.LogLevel>(options, info0);

LockFile\AssetsLogMessage.cs (6)

20[JsonConverter(typeof(JsonStringEnumConverter<LogLevel>))] 21public LogLevel Level { get; } 33get => Level == LogLevel.Warning ? WarningLevel : null; 82LogLevel level, 107public AssetsLogMessage(LogLevel logLevel, NuGetLogCode errorCode, 123public AssetsLogMessage(LogLevel logLevel, NuGetLogCode errorCode, string errorString)

LockFile\IAssetsLogMessage.cs (1)

16LogLevel Level { get; }

LockFile\LockFileFormat.cs (2)

298writer.WriteValue(Enum.GetName(typeof(LogLevel), logMessage.Level)); 300if (logMessage.Level == LogLevel.Warning)

LockFile\Utf8JsonStreamIAssetsLogMessageConverter.cs (2)

21/// "level": "<see cref="Common.LogLevel"/>", 57LogLevel level = default;

Plugins\Messages\LogRequest.cs (3)

22public LogLevel LogLevel { get; } 40public LogRequest(LogLevel logLevel, string message) 42if (!Enum.IsDefined(typeof(LogLevel), logLevel))

Plugins\Messages\SetLogLevelRequest.cs (3)

20public LogLevel LogLevel { get; } 29public SetLogLevelRequest(LogLevel logLevel) 31if (!Enum.IsDefined(typeof(LogLevel), logLevel))

Plugins\RequestHandlers\LogRequestHandler.cs (9)

19private LogLevel _logLevel; 125public static LogLevel GetLogLevel(ILogger logger) 139return LogLevel.Information; 146case LogLevel.Debug: 150case LogLevel.Verbose: 154case LogLevel.Information: 158case LogLevel.Minimal: 162case LogLevel.Warning: 166case LogLevel.Error:

RemoteRepositories\PluginFindPackageByIdResource.cs (1)

503var logLevel = LogRequestHandler.GetLogLevel(logger);

Resources\DownloadResourcePlugin.cs (1)

169var logLevel = LogRequestHandler.GetLogLevel(logger);