Information

Diagnostics\FileLoggerProvider.cs (1)

Interaction\ExtensionInteractionService.cs (2)

398var result = _extensionTaskChannel.Writer.TryWrite(() => Backchannel.LogMessageAsync(LogLevel.Information, markdown, _cancellationToken)); 406var result = _extensionTaskChannel.Writer.TryWrite(() => Backchannel.LogMessageAsync(LogLevel.Information, markup.RemoveSpectreFormatting(), _cancellationToken));

Interaction\SpectreConsoleLoggerProvider.cs (1)

70LogLevel.Information => "info",

Utils\OutputCollector.cs (1)

63_fileLogger?.WriteLog(DateTimeOffset.UtcNow, stream == OutputLineStream.StdErr ? LogLevel.Error : LogLevel.Information, _category, line);

Commands\RunCommandTests.cs (2)

266LogLevel = LogLevel.Information, 1514LogLevel = LogLevel.Information,

Interaction\SpectreConsoleLoggerProviderTests.cs (2)

36Assert.True(aspireLogger.IsEnabled(LogLevel.Information)); 40Assert.False(systemLogger.IsEnabled(LogLevel.Information));

Components\Pages\StructuredLogs.razor.cs (1)

210new SelectViewModel<LogLevel?> { Id = LogLevel.Information, Name = "Information" },

DashboardWebApplication.cs (4)

148builder.Logging.AddFilter("Grpc", LogLevel.Information); 149builder.Logging.AddFilter("Aspire.Dashboard.Authentication", LogLevel.Information); 150builder.Logging.AddFilter("Aspire.Dashboard.Otlp", LogLevel.Information); 151builder.Logging.AddFilter("Microsoft", LogLevel.Information);

Otlp\Model\OtlpLogEntry.cs (4)

107SeverityNumberProto.Info => LogLevel.Information, 108SeverityNumberProto.Info2 => LogLevel.Information, 109SeverityNumberProto.Info3 => LogLevel.Information, 110SeverityNumberProto.Info4 => LogLevel.Information,

Integration\FrontendBrowserTokenAuthTests.cs (1)

170var l = testSink.Writes.Where(w => w.LoggerName == typeof(DashboardWebApplication).FullName && w.LogLevel >= LogLevel.Information).ToList();

Integration\OtlpHttpJsonTests.cs (2)

503Assert.Equal(LogLevel.Information, log.Severity); 579Assert.Equal(LogLevel.Information, log.Severity);

Integration\StartupTests.cs (3)

685var l = testSink.Writes.Where(w => w.LoggerName == typeof(DashboardWebApplication).FullName && w.LogLevel >= LogLevel.Information).ToList(); 753var l = testSink.Writes.Where(w => w.LoggerName == typeof(DashboardWebApplication).FullName && w.LogLevel >= LogLevel.Information).ToList(); 900var l = testSink.Writes.Where(w => w.LoggerName == typeof(DashboardWebApplication).FullName && w.LogLevel >= LogLevel.Information).ToList();

Ats\LoggingExports.cs (2)

127"information" or "info" => LogLevel.Information, 132_ => LogLevel.Information

Dashboard\DashboardEventHandlers.cs (1)

854var level = logLine.IsErrorMessage ? LogLevel.Error : LogLevel.Information;

Dcp\DcpLogParser.cs (2)

27logLevel = LogLevel.Information; 74logLevel = LogLevel.Information;

DistributedApplicationBuilder.cs (2)

541"info" or "information" => LogLevel.Information, 545_ => LogLevel.Information

Pipelines\DistributedApplicationPipeline.cs (1)

1059context.ReportingStep.Log(LogLevel.Information, sb.ToString());

Pipelines\PipelineLoggingOptions.cs (1)

16public LogLevel MinimumLogLevel { get; set; } = LogLevel.Information;

ResourceLoggerForwarderService.cs (1)

71var logLevel = line.IsErrorMessage ? LogLevel.Error : LogLevel.Information;

AzureContainerAppResource.cs (2)

56ctx.ReportingStep.Log(LogLevel.Information, new MarkdownString($"Successfully deployed **{targetResource.Name}** to [{endpoint}]({endpoint})")); 61ctx.ReportingStep.Log(LogLevel.Information, new MarkdownString($"Successfully deployed **{targetResource.Name}** to Azure Container Apps environment **{containerAppEnv.Name}**. No public endpoints were configured."));

AzureAppServiceWebSiteResource.cs (1)

60ctx.ReportingStep.Log(LogLevel.Information, new MarkdownString($"Successfully deployed **{targetResource.Name}** to [{endpoint}]({endpoint})"));

DockerComposePublisherLoggerExtensions.cs (3)

19[LoggerMessage(LogLevel.Information, "{Message}")] 22[LoggerMessage(LogLevel.Information, "Generating Compose output")] 25[LoggerMessage(LogLevel.Information, "No resources found in the model.")]

DockerComposeServiceResource.cs (3)

334context.ReportingStep.Log(LogLevel.Information, 349context.ReportingStep.Log(LogLevel.Information, new MarkdownString($"Successfully deployed **{TargetResource.Name}** to {endpointList}.")); 355context.ReportingStep.Log(LogLevel.Information,

HostedAgent\AzureHostedAgentResource.cs (1)

45ctx.ReportingStep.Log(LogLevel.Information, $"Successfully deployed **{Name}** as Hosted Agent (version {version})", enableMarkdown: true);

HostedAgent\AzurePromptAgentResource.cs (1)

46ctx.ReportingStep.Log(LogLevel.Information, $"Successfully deployed **{Name}** as Prompt Agent (version {version})", enableMarkdown: true);

KubernetesPublisherLoggerExtensions.cs (4)

13[LoggerMessage(LogLevel.Information, "{Message}")] 16[LoggerMessage(LogLevel.Information, "Generating Kubernetes output")] 19[LoggerMessage(LogLevel.Information, "No resources found in the model.")] 22[LoggerMessage(LogLevel.Information, "Successfully generated Kubernetes output in '{OutputPath}'")]

AtsExportsTests.cs (1)

62Assert.Equal(LogLevel.Information, result);

ResourceLoggerForwarderServiceTests.cs (4)

136log => { Assert.Equal(LogLevel.Information, log.Level); Assert.Equal("1: 2000-12-29T20:59:59.0000000Z Test trace message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); }, 137log => { Assert.Equal(LogLevel.Information, log.Level); Assert.Equal("2: 2000-12-29T20:59:59.0000000Z Test debug message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); }, 138log => { Assert.Equal(LogLevel.Information, log.Level); Assert.Equal("3: 2000-12-29T20:59:59.0000000Z Test information message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); }, 139log => { Assert.Equal(LogLevel.Information, log.Level); Assert.Equal("4: 2000-12-29T20:59:59.0000000Z Test warning message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); },

Backchannel\BackchannelLoggerProviderTests.cs (1)

28Assert.Equal(LogLevel.Information, snapshot[0].LogLevel);

Dashboard\DashboardLifecycleHookTests.cs (1)

206b.SetMinimumLevel(LogLevel.Information);

Dashboard\DashboardResourceTests.cs (1)

555[InlineData(LogLevel.Information)]

Dcp\DcpLogParserTests.cs (6)

26Assert.Equal(LogLevel.Information, logLevel); 111Assert.Equal(LogLevel.Information, logLevel); 127Assert.Equal(LogLevel.Information, logLevel); 186Assert.Equal(LogLevel.Information, logLevel); 216Assert.Equal(LogLevel.Information, logLevel); 223[InlineData("info", LogLevel.Information)]

Pipelines\DistributedApplicationPipelineTests.cs (7)

1159Assert.Contains(reporter.LoggedMessages, log => log.Message == "Test log message from pipeline step" && log.LogLevel == LogLevel.Information); 1215Assert.Contains(reporter.LoggedMessages, log => log.Message == "Message from step 1" && log.LogLevel == LogLevel.Information); 1216Assert.Contains(reporter.LoggedMessages, log => log.Message == "Message from step 2" && log.LogLevel == LogLevel.Information); 1255Assert.Contains(reporter.LoggedMessages, log => log.Message == "About to fail" && log.LogLevel == LogLevel.Information); 1316Assert.Contains(reporter.LoggedMessages, log => log.Message.Contains("Executing step 1") && log.LogLevel == LogLevel.Information); 1317Assert.Contains(reporter.LoggedMessages, log => log.Message.Contains("Executing step 2") && log.LogLevel == LogLevel.Information); 1318Assert.Contains(reporter.LoggedMessages, log => log.Message.Contains("Executing step 3") && log.LogLevel == LogLevel.Information);

Pipelines\PipelineLoggerProviderTests.cs (2)

115Assert.Equal(LogLevel.Information, logEntry1.Level); 120Assert.Equal(LogLevel.Information, logEntry2.Level);

Publishing\PipelineActivityReporterTests.cs (2)

954var logLevel = LogLevel.Information; 994step.Log(LogLevel.Information, "Test log");

src\Components\Aspire.RabbitMQ.Client\RabbitMQEventSourceLogForwarder.cs (2)

65EventLevel.Informational => LogLevel.Information, 68EventLevel.LogAlways => LogLevel.Information,

AspireRabbitMQLoggingTests.cs (2)

74Assert.Contains(logs, l => l.Level == LogLevel.Information && l.Message == "Performing automatic recovery"); 95Assert.Equal(LogLevel.Information, logs[0].Level);

tests\Aspire.RabbitMQ.Client.Tests\AspireRabbitMQLoggingTests.cs (2)

74Assert.Contains(logs, l => l.Level == LogLevel.Information && l.Message == "Performing automatic recovery"); 95Assert.Equal(LogLevel.Information, logs[0].Level);

Program.cs (1)

121_ => LogLevel.Information

Program.cs (1)

22factory.AddFilter("Console", level => level >= LogLevel.Information);

Consumer.cs (1)

24void LogString(string message) => logger.Log(LogLevel.Information, 0, message, null, (s, _) => s);

src\Shared\Http2cat\Http2CatHostedService.cs (3)

68if (_logger.IsEnabled(LogLevel.Information)) 75if (_logger.IsEnabled(LogLevel.Information)) 104if (_logger.IsEnabled(LogLevel.Information))

src\Shared\Http2cat\Http2CatHostedService.cs (3)

68if (_logger.IsEnabled(LogLevel.Information)) 75if (_logger.IsEnabled(LogLevel.Information)) 104if (_logger.IsEnabled(LogLevel.Information))

src\Shared\Http2cat\Http2CatHostedService.cs (3)

68if (_logger.IsEnabled(LogLevel.Information)) 75if (_logger.IsEnabled(LogLevel.Information)) 104if (_logger.IsEnabled(LogLevel.Information))

src\Shared\Http2cat\Http2CatHostedService.cs (3)

68if (_logger.IsEnabled(LogLevel.Information)) 75if (_logger.IsEnabled(LogLevel.Information)) 104if (_logger.IsEnabled(LogLevel.Information))

StrictTestServerTests.cs (1)

20if (TestSink.Writes.FirstOrDefault(w => w.LogLevel > LogLevel.Information) is WriteContext writeContext)

src\Shared\Http2cat\Http2CatHostedService.cs (3)

68if (_logger.IsEnabled(LogLevel.Information)) 75if (_logger.IsEnabled(LogLevel.Information)) 104if (_logger.IsEnabled(LogLevel.Information))

ChunkedRequestTests.cs (1)

1140Assert.All(TestSink.Writes, w => Assert.InRange(w.LogLevel, LogLevel.Trace, LogLevel.Information));

Http2\Http2ConnectionTests.cs (1)

5484var logMessage = LogMessages.Single(m => m.LogLevel >= LogLevel.Information);

RequestBodyTimeoutTests.cs (2)

143Assert.Contains(TestSink.Writes, w => w.EventId.Id == 32 && w.LogLevel == LogLevel.Information); 144Assert.Contains(TestSink.Writes, w => w.EventId.Id == 33 && w.LogLevel == LogLevel.Information);

RequestTests.cs (1)

2030Assert.All(TestSink.Writes, w => Assert.InRange(w.LogLevel, LogLevel.Trace, LogLevel.Information));

src\Servers\Kestrel\shared\test\TestServiceContext.cs (1)

60HttpParser = new HttpParser<Http1ParsingHandler>(Log.IsEnabled(LogLevel.Information), disableHttp1LineFeedTerminators);

Program.cs (5)

132factory.AddFilter("Console", level => level >= LogLevel.Information); 156factory.AddFilter("Console", level => level >= LogLevel.Information); 176factory.AddFilter("Console", level => level >= LogLevel.Information); 193factory.AddFilter("Console", level => level >= LogLevel.Information); 218factory.AddFilter("Console", level => level >= LogLevel.Information);

Program.cs (1)

17factory.AddFilter("Console", level => level >= LogLevel.Information);

CompactConsoleLoggerFormatter.cs (3)

46_messagePadding = new string(' ', GetLogLevelString(LogLevel.Information).Length + LoglevelPadding.Length + (_options.TimestampFormat?.Length ?? 0)); 108LogLevel.Information => "info", 128LogLevel.Information => (ConsoleColor.DarkGreen, ConsoleColor.Black),

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggingExtensions.cs (5)

8[LoggerMessage(4, LogLevel.Information, "Error from RemoteAuthentication: {ErrorMessage}.", EventName = "RemoteAuthenticationFailed")] 17[LoggerMessage(7, LogLevel.Information, "{AuthenticationScheme} was not authenticated. Failure message: {FailureMessage}", EventName = "AuthenticationSchemeNotAuthenticatedWithFailure")] 26[LoggerMessage(12, LogLevel.Information, "AuthenticationScheme: {AuthenticationScheme} was challenged.", EventName = "AuthenticationSchemeChallenged")] 29[LoggerMessage(13, LogLevel.Information, "AuthenticationScheme: {AuthenticationScheme} was forbidden.", EventName = "AuthenticationSchemeForbidden")] 41[LoggerMessage(17, LogLevel.Information, "Access was denied by the resource owner or by the remote server.", EventName = "AccessDenied")]

LoggerMessage.g.cs (22)

LoggingExtensions.cs (1)

8[LoggerMessage(1, LogLevel.Information, "AuthenticationScheme: {AuthenticationScheme} signed in.", EventName = "AuthenticationSchemeSignedIn")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggingExtensions.cs (2)

8[LoggerMessage(10, LogLevel.Information, "AuthenticationScheme: {AuthenticationScheme} signed in.", EventName = "AuthenticationSchemeSignedIn")] 11[LoggerMessage(11, LogLevel.Information, "AuthenticationScheme: {AuthenticationScheme} signed out.", EventName = "AuthenticationSchemeSignedOut")]

LoggerMessage.g.cs (22)

LoggingExtensions.cs (1)

8[LoggerMessage(1, LogLevel.Information, "Failed to validate the token.", EventName = "TokenValidationFailed")]

Internal\NegotiateLoggingExtensions.cs (2)

8[LoggerMessage(1, LogLevel.Information, "Incomplete Negotiate handshake, sending an additional 401 Negotiate challenge.", EventName = "IncompleteNegotiateChallenge")] 29[LoggerMessage(8, LogLevel.Information, "Deferring to the server's implementation of Windows Authentication.", EventName = "Deferring")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggingExtensions.cs (2)

152[LoggerMessage(46, LogLevel.Information, "Remote signout request processed.", EventName = "RemoteSignOut")] 163[LoggerMessage(49, LogLevel.Information, "AuthenticationScheme: {AuthenticationScheme} signed out.", EventName = "AuthenticationSchemeSignedOut")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggingExtensions.cs (1)

26[LoggerMessage(7, LogLevel.Information, "Remote signout request processed.", EventName = "RemoteSignOut")]

LoggerMessage.g.cs (22)

LoggingExtensions.cs (1)

14[LoggerMessage(2, LogLevel.Information, "Authorization failed. {Reason}", EventName = "UserAuthorizationFailed")]

DefaultAuthorizationServiceTests.cs (2)

1190Assert.Equal(LogLevel.Information, level); 1223Assert.Equal(LogLevel.Information, level);

PageInformation.cs (2)

100"info" => LogLevel.Information, 104_ => LogLevel.Information

LoggerMessage.g.cs (22)

Builder\OpaqueRedirection.cs (1)

104[LoggerMessage(1, LogLevel.Information, "Opaque URL unprotection failed.", EventName = "OpaqueUrlUnprotectionFailed")]

LoggerMessage.g.cs (22)

RazorComponentEndpointInvoker.cs (1)

332[LoggerMessage(5, LogLevel.Information, "Antiforgery token validation failed for the current request.", EventName = nameof(EndpointAntiforgeryValidationFailed))]

Circuits\RemoteRenderer.cs (1)

399[LoggerMessage(103, LogLevel.Information, "Sending data for batch failed: {Message}", EventName = "SendBatchDataFailed")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

Services\WebAssemblyConsoleLogger.cs (3)

16private static readonly string _messagePadding = new(' ', GetLogLevelString(LogLevel.Information).Length + _loglevelPadding.Length); 82case LogLevel.Information: 146case LogLevel.Information:

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

CORSLoggerExtensions.cs (6)

19[LoggerMessage(4, LogLevel.Information, "CORS policy execution successful.", EventName = "PolicySuccess")] 22[LoggerMessage(5, LogLevel.Information, "CORS policy execution failed.", EventName = "PolicyFailure")] 25[LoggerMessage(6, LogLevel.Information, "Request origin {origin} does not have permission to access the resource.", EventName = "OriginNotAllowed")] 28[LoggerMessage(7, LogLevel.Information, "Request method {accessControlRequestMethod} not allowed in CORS policy.", EventName = "AccessControlMethodNotAllowed")] 31[LoggerMessage(8, LogLevel.Information, "Request header '{requestHeader}' not allowed in CORS policy.", EventName = "RequestHeaderNotAllowed")] 37[LoggerMessage(10, LogLevel.Information, "No CORS policy found for the specified request.", EventName = "NoCorsPolicyFound")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggingExtensions.cs (11)

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

Buffering\PerIncomingRequestLoggingBuilderExtensionsTests.cs (9)

Buffering\PerRequestLogBufferingOptionsConfigureOptionsTests.cs (1)

94Assert.Equal(LogLevel.Information, options.Rules[0].LogLevel);

Logging\AcceptanceTests.cs (26)

Logging\AcceptanceTests.Mvc.cs (10)

60LogLevel.Information, 75Assert.Equal(LogLevel.Information, logRecord.Level); 95LogLevel.Information, 110Assert.Equal(LogLevel.Information, logRecord.Level); 134LogLevel.Information, 156Assert.Equal(LogLevel.Information, logRecord.Level); 185LogLevel.Information, 200Assert.Equal(LogLevel.Information, logRecord.Level); 223LogLevel.Information, 241Assert.Equal(LogLevel.Information, logRecord.Level);

Logging\AcceptanceTests.Routing.cs (2)

61LogLevel.Information, 75Assert.Equal(LogLevel.Information, logRecord.Level);

WebApplicationFunctionalTests.cs (2)

35logger.Log(LogLevel.Information, 0, "Message", null, (s, e) => 78logger.Log(LogLevel.Information, 0, "Message", null, (s, e) =>

WebHostFunctionalTests.cs (1)

129logger.Log(LogLevel.Information, 0, "Message", null, (s, e) =>

Internal\GrpcServerLog.cs (4)

11[LoggerMessage(1, LogLevel.Information, "Request content-type of '{ContentType}' is not supported.", EventName = "UnsupportedRequestContentType")] 17[LoggerMessage(3, LogLevel.Information, "Error status code '{StatusCode}' with detail '{Detail}' raised.", EventName = "RpcConnectionError")] 29[LoggerMessage(7, LogLevel.Information, "Error reading message.", EventName = "ErrorReadingMessage")] 38[LoggerMessage(10, LogLevel.Information, "Error sending message.", EventName = "ErrorSendingMessage")]

LoggerMessage.g.cs (22)

LoggerExtensions.cs (2)

19[LoggerMessage(3, LogLevel.Information, "{Protocol} request rejected due to missing or empty host header.", EventName = "RequestRejectedMissingHost")] 28[LoggerMessage(6, LogLevel.Information, "The host '{Host}' does not match an allowed host.", EventName = "NoAllowedHostMatched")]

LoggerMessage.g.cs (22)

GenericHost\GenericWebHostService.cs (2)

169if (LifetimeLogger.IsEnabled(LogLevel.Information)) 211[LoggerMessage(14, LogLevel.Information,

Internal\HostingApplicationDiagnostics.cs (4)

140if (_logger.IsEnabled(LogLevel.Information)) 276logLevel: LogLevel.Information, 294logLevel: LogLevel.Information, 306logLevel: LogLevel.Information,

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

HttpConnection.Log.cs (2)

21[LoggerMessage(3, LogLevel.Information, "HttpConnection Started.", EventName = "Started")] 30[LoggerMessage(6, LogLevel.Information, "HttpConnection Disposed.", EventName = "Disposed")]

Internal\LongPollingTransport.Log.cs (2)

16[LoggerMessage(1, LogLevel.Information, "Starting transport. Transfer mode: {TransferFormat}.", EventName = "StartTransport")] 25[LoggerMessage(6, LogLevel.Information, "Transport is stopping.", EventName = "TransportStopping")]

Internal\ServerSentEventsTransport.Log.cs (2)

16[LoggerMessage(1, LogLevel.Information, "Starting transport. Transfer mode: {TransferFormat}.", EventName = "StartTransport")] 25[LoggerMessage(6, LogLevel.Information, "Transport is stopping.", EventName = "TransportStopping")]

Internal\WebSocketsTransport.Log.cs (5)

15[LoggerMessage(1, LogLevel.Information, "Starting transport. Transfer mode: {TransferFormat}. Url: '{WebSocketUrl}'.", EventName = "StartTransport")] 24[LoggerMessage(6, LogLevel.Information, "Transport is stopping.", EventName = "TransportStopping")] 45[LoggerMessage(11, LogLevel.Information, "WebSocket closed by the server. Close status {CloseStatus}.", EventName = "WebSocketClosed")] 54[LoggerMessage(14, LogLevel.Information, "Sending a message canceled.", EventName = "SendMessageCanceled")] 60[LoggerMessage(16, LogLevel.Information, "Closing WebSocket.", EventName = "ClosingWebSocket")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

ChallengeHttpResult.cs (2)

97if (logger.IsEnabled(LogLevel.Information)) 103[LoggerMessage(1, LogLevel.Information, "Executing ChallengeResult with authentication schemes ({Schemes}).", EventName = "ChallengeResultExecuting", SkipEnabledCheck = true)]

ForbidHttpResult.cs (2)

108if (logger.IsEnabled(LogLevel.Information)) 114[LoggerMessage(1, LogLevel.Information, "Executing ChallengeResult with authentication schemes ({Schemes}).", EventName = "ChallengeResultExecuting", SkipEnabledCheck = true)]

HttpResultsHelper.cs (4)

164[LoggerMessage(1, LogLevel.Information, 169[LoggerMessage(2, LogLevel.Information, 174[LoggerMessage(3, LogLevel.Information, "Writing value of type '{Type}' as Json.", 178[LoggerMessage(5, LogLevel.Information,

LoggerMessage.g.cs (22)

RedirectHttpResult.cs (1)

138[LoggerMessage(1, LogLevel.Information,

RedirectToRouteHttpResult.cs (1)

195[LoggerMessage(1, LogLevel.Information,

SignInHttpResult.cs (1)

71[LoggerMessage(1, LogLevel.Information,

SignOutHttpResult.cs (2)

97if (logger.IsEnabled(LogLevel.Information)) 103[LoggerMessage(1, LogLevel.Information,

HttpLoggingExtensions.cs (6)

11LogLevel.Information, 17LogLevel.Information, 23[LoggerMessage(3, LogLevel.Information, "RequestBody: {Body}{Status}", EventName = "RequestBody")] 26[LoggerMessage(4, LogLevel.Information, "ResponseBody: {Body}", EventName = "ResponseBody")] 38[LoggerMessage(8, LogLevel.Information, "Duration: {Duration}ms", EventName = "Duration")] 42LogLevel.Information,

HttpLoggingMiddleware.cs (1)

55if (!_logger.IsEnabled(LogLevel.Information))

LoggerMessage.g.cs (22)

HttpLoggingMiddlewareTests.cs (2)

1611var lines = Assert.Single(TestSink.Writes.Where(w => w.LogLevel >= LogLevel.Information)).Message.Split(Environment.NewLine); 1740var lines = Assert.Single(TestSink.Writes.Where(w => w.LogLevel >= LogLevel.Information)).Message.Split(Environment.NewLine);

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

Areas\Identity\Pages\V4\Account\ExternalLogin.cshtml.cs (2)

144if (_logger.IsEnabled(LogLevel.Information)) 194if (_logger.IsEnabled(LogLevel.Information))

Areas\Identity\Pages\V5\Account\ExternalLogin.cshtml.cs (2)

144if (_logger.IsEnabled(LogLevel.Information)) 194if (_logger.IsEnabled(LogLevel.Information))

LoggedTestXunitTests.cs (4)

67[LogLevel(LogLevel.Information)] 74Assert.Equal(LogLevel.Information, message.LogLevel); 91[LogLevel(LogLevel.Information)] 98Assert.Equal(LogLevel.Information, message.LogLevel);

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

ChallengeResult.cs (2)

117if (logger.IsEnabled(LogLevel.Information)) 123[LoggerMessage(1, LogLevel.Information, "Executing ChallengeResult with authentication schemes ({Schemes}).", EventName = "ChallengeResultExecuting", SkipEnabledCheck = true)]

ForbidResult.cs (2)

118if (logger.IsEnabled(LogLevel.Information)) 124[LoggerMessage(1, LogLevel.Information, $"Executing {nameof(ForbidResult)} with authentication schemes ({{Schemes}}).", EventName = "ForbidResultExecuting", SkipEnabledCheck = true)]

Infrastructure\ContentResultExecutor.cs (1)

77[LoggerMessage(1, LogLevel.Information, "Executing ContentResult with HTTP Response ContentType of {ContentType}", EventName = "ContentResultExecuting")]

Infrastructure\ControllerActionInvoker.cs (4)

621if (logger.IsEnabled(LogLevel.Information)) 641[LoggerMessage(101, LogLevel.Information, "Executing action method {ActionName} - Validation state: {ValidationState}", EventName = "ActionMethodExecuting", SkipEnabledCheck = true)] 649if (logger.IsEnabled(LogLevel.Information)) 656[LoggerMessage(103, LogLevel.Information, "Executed action method {ActionName}, returned result {ActionResult} in {ElapsedMilliseconds}ms.", EventName = "ActionMethodExecuted", SkipEnabledCheck = true)]

Infrastructure\DefaultActionDescriptorCollectionProvider.cs (1)

177Level = LogLevel.Information,

Infrastructure\FileContentResultExecutor.cs (2)

79if (logger.IsEnabled(LogLevel.Information)) 86[LoggerMessage(2, LogLevel.Information, "Executing {FileResultType}, sending file with download name '{FileDownloadName}' ...", EventName = "ExecutingFileResultWithNoFileName", SkipEnabledCheck = true)]

Infrastructure\FileStreamResultExecutor.cs (2)

91if (logger.IsEnabled(LogLevel.Information)) 98[LoggerMessage(1, LogLevel.Information, "Executing {FileResultType}, sending file with download name '{FileDownloadName}' ...", EventName = "ExecutingFileResultWithNoFileName", SkipEnabledCheck = true)]

Infrastructure\LocalRedirectResultExecutor.cs (1)

68[LoggerMessage(1, LogLevel.Information, "Executing LocalRedirectResult, redirecting to {Destination}.", EventName = "LocalRedirectResultExecuting")]

Infrastructure\ObjectResultExecutor.cs (2)

159if (logger.IsEnabled(LogLevel.Information)) 167[LoggerMessage(1, LogLevel.Information, "Executing {ObjectResultType}, writing value of type '{Type}'.", EventName = "ObjectResultExecuting", SkipEnabledCheck = true)]

Infrastructure\PhysicalFileResultExecutor.cs (2)

167if (logger.IsEnabled(LogLevel.Information)) 174[LoggerMessage(1, LogLevel.Information, "Executing {FileResultType}, sending file '{FileDownloadPath}' with download name '{FileDownloadName}' ...", EventName = "ExecutingFileResult", SkipEnabledCheck = true)]

Infrastructure\RedirectResultExecutor.cs (1)

65[LoggerMessage(1, LogLevel.Information, "Executing RedirectResult, redirecting to {Destination}.", EventName = "RedirectResultExecuting")]

Infrastructure\RedirectToActionResultExecutor.cs (1)

71[LoggerMessage(1, LogLevel.Information, "Executing RedirectResult, redirecting to {Destination}.", EventName = "RedirectToActionResultExecuting")]

Infrastructure\RedirectToPageResultExecutor.cs (1)

71[LoggerMessage(1, LogLevel.Information, "Executing RedirectToPageResult, redirecting to {Page}.", EventName = "RedirectToPageResultExecuting")]

Infrastructure\RedirectToRouteResultExecutor.cs (1)

67[LoggerMessage(1, LogLevel.Information, "Executing RedirectToRouteResult, redirecting to {Destination} from route {RouteName}.", EventName = "RedirectToRouteResultExecuting")]

Infrastructure\ResourceInvoker.cs (1)

63if (_diagnosticListener.IsEnabled() || _logger.IsEnabled(LogLevel.Information))

Infrastructure\ResourceInvoker.Log.cs (8)

22if (logger.IsEnabled(LogLevel.Information)) 67[LoggerMessage(101, LogLevel.Information, "Route matched with {RouteData}. Executing action {ActionName}", EventName = "ActionExecuting", SkipEnabledCheck = true)] 70[LoggerMessage(102, LogLevel.Information, "Route matched with {RouteData}. Executing controller action with signature {MethodInfo} on controller {Controller} ({AssemblyName}).", EventName = "ControllerActionExecuting", SkipEnabledCheck = true)] 73[LoggerMessage(103, LogLevel.Information, "Route matched with {RouteData}. Executing page {PageName}", EventName = "PageExecuting", SkipEnabledCheck = true)] 76[LoggerMessage(3, LogLevel.Information, "Authorization failed for the request at filter '{AuthorizationFilter}'.", EventName = "AuthorizationFailure")] 101if (logger.IsEnabled(LogLevel.Information)) 114[LoggerMessage(104, LogLevel.Information, "Executed page {PageName} in {ElapsedMilliseconds}ms", EventName = "PageExecuted", SkipEnabledCheck = true)] 117[LoggerMessage(105, LogLevel.Information, "Executed action {ActionName} in {ElapsedMilliseconds}ms", EventName = "ActionExecuted", SkipEnabledCheck = true)]

Infrastructure\SystemTextJsonResultExecutor.cs (2)

132[LoggerMessage(1, LogLevel.Information, "Executing JsonResult, writing value of type '{Type}'.", EventName = "JsonResultExecuting", SkipEnabledCheck = true)] 137if (logger.IsEnabled(LogLevel.Information))

Infrastructure\VirtualFileResultExecutor.cs (2)

149if (logger.IsEnabled(LogLevel.Information)) 156[LoggerMessage(1, LogLevel.Information, "Executing {FileResultType}, sending file '{FileDownloadPath}' with download name '{FileDownloadName}' ...", EventName = "ExecutingFileResult", SkipEnabledCheck = true)]

LoggerMessage.g.cs (22)

SignInResult.cs (1)

92[LoggerMessage(1, LogLevel.Information, $"Executing {nameof(SignInResult)} with authentication scheme ({{Scheme}}) and the following principal: {{Principal}}.", EventName = "SignInResultExecuting")]

SignOutResult.cs (2)

134if (logger.IsEnabled(LogLevel.Information)) 140[LoggerMessage(1, LogLevel.Information, $"Executing {nameof(SignOutResult)} with authentication schemes ({{Schemes}}).", EventName = "SignOutResultExecuting", SkipEnabledCheck = true)]

StatusCodeResult.cs (1)

48[LoggerMessage(1, LogLevel.Information, "Executing StatusCodeResult, setting HTTP status code {StatusCode}", EventName = "HttpStatusCodeResultExecuting")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

NewtonsoftJsonResultExecutor.cs (2)

179[LoggerMessage(2, LogLevel.Information, "Executing JsonResult, writing value of type '{Type}'.", EventName = "JsonResultExecuting", SkipEnabledCheck = true)] 184if (logger.IsEnabled(LogLevel.Information))

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

PageLoggerExtensions.cs (8)

79[LoggerMessage(105, LogLevel.Information, "Executing handler method {HandlerName} - ModelState is {ValidationState}", EventName = "ExecutingHandlerMethod", SkipEnabledCheck = true)] 87if (logger.IsEnabled(LogLevel.Information)) 108[LoggerMessage(107, LogLevel.Information, "Executing an implicit handler method - ModelState is {ValidationState}", EventName = "ExecutingImplicitHandlerMethod", SkipEnabledCheck = true)] 113if (logger.IsEnabled(LogLevel.Information)) 121[LoggerMessage(108, LogLevel.Information, "Executed handler method {HandlerName}, returned result {ActionResult}.", EventName = "ExecutedHandlerMethod")] 126if (logger.IsEnabled(LogLevel.Information)) 133[LoggerMessage(109, LogLevel.Information, "Executed an implicit handler method, returned result {ActionResult}.", EventName = "ExecutedImplicitHandlerMethod", SkipEnabledCheck = true)] 138if (logger.IsEnabled(LogLevel.Information))

LoggerMessage.g.cs (22)

Filters\AntiforgeryMiddlewareAuthorizationFilter.cs (1)

34[LoggerMessage(1, LogLevel.Information, "Antiforgery token validation failed. {Message}", EventName = "AntiforgeryTokenInvalid")]

Filters\ValidateAntiforgeryTokenAuthorizationFilter.cs (1)

56[LoggerMessage(1, LogLevel.Information, "Antiforgery token validation failed. {Message}", EventName = "AntiforgeryTokenInvalid")]

LoggerMessage.g.cs (22)

PartialViewResultExecutor.cs (2)

192[LoggerMessage(1, LogLevel.Information, "Executing PartialViewResult, running view {PartialViewName}.", EventName = "PartialViewResultExecuting")] 206[LoggerMessage(4, LogLevel.Information, "Executed PartialViewResult - view {PartialViewName} executed in {ElapsedMilliseconds}ms.", EventName = "PartialViewResultExecuted")]

ViewComponentResultExecutor.cs (1)

164[LoggerMessage(1, LogLevel.Information, "Executing ViewComponentResult, running {ViewComponentName}.", EventName = "ViewComponentResultExecuting")]

ViewResultExecutor.cs (2)

192[LoggerMessage(1, LogLevel.Information, "Executing ViewResult, running view {ViewName}.", EventName = "ViewResultExecuting")] 206[LoggerMessage(4, LogLevel.Information, "Executed ViewResult - view {ViewName} executed in {ElapsedMilliseconds}ms.", EventName = "ViewResultExecuted")]

LoggerExtensions.cs (6)

25[LoggerMessage(4, LogLevel.Information, "The content requested has not been modified.", EventName = "NotModifiedServed")] 28[LoggerMessage(5, LogLevel.Information, "Serving response from cache.", EventName = "CachedResponseServed")] 31[LoggerMessage(6, LogLevel.Information, "No cached response available for this request and the 'only-if-cached' cache directive was specified.", 35[LoggerMessage(7, LogLevel.Information, "No cached response available for this request.", EventName = "NoResponseServed")] 38[LoggerMessage(8, LogLevel.Information, "The response has been cached.", EventName = "ResponseCached")] 41[LoggerMessage(9, LogLevel.Information, "The response could not be cached for this request.", EventName = "ResponseNotCached")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

TestUtils.cs (6)

302internal static LoggedMessage NotModifiedServed => new LoggedMessage(4, LogLevel.Information); 303internal static LoggedMessage CachedResponseServed => new LoggedMessage(5, LogLevel.Information); 304internal static LoggedMessage GatewayTimeoutServed => new LoggedMessage(6, LogLevel.Information); 305internal static LoggedMessage NoResponseServed => new LoggedMessage(7, LogLevel.Information); 306internal static LoggedMessage ResponseCached => new LoggedMessage(8, LogLevel.Information); 307internal static LoggedMessage ResponseNotCached => new LoggedMessage(9, LogLevel.Information);

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggerExtensions.cs (6)

92[LoggerMessage(21, LogLevel.Information, "The content requested has not been modified.", EventName = "NotModifiedServed")] 95[LoggerMessage(22, LogLevel.Information, "Serving response from cache.", EventName = "CachedResponseServed")] 98[LoggerMessage(23, LogLevel.Information, "No cached response available for this request and the 'only-if-cached' cache directive was specified.", 102[LoggerMessage(24, LogLevel.Information, "No cached response available for this request.", EventName = "NoResponseServed")] 108[LoggerMessage(26, LogLevel.Information, "The response has been cached.", EventName = "ResponseCached")] 111[LoggerMessage(27, LogLevel.Information, "The response could not be cached for this request.", EventName = "ResponseNotCached")]

LoggerMessage.g.cs (22)

TestUtils.cs (6)

295internal static LoggedMessage NotModifiedServed => new LoggedMessage(21, LogLevel.Information); 296internal static LoggedMessage CachedResponseServed => new LoggedMessage(22, LogLevel.Information); 297internal static LoggedMessage GatewayTimeoutServed => new LoggedMessage(23, LogLevel.Information); 298internal static LoggedMessage NoResponseServed => new LoggedMessage(24, LogLevel.Information); 300internal static LoggedMessage ResponseCached => new LoggedMessage(26, LogLevel.Information); 301internal static LoggedMessage ResponseNotCached => new LoggedMessage(27, LogLevel.Information);

LoggerMessage.g.cs (22)

Extensions\RewriteMiddlewareLoggingExtensions.cs (5)

31[LoggerMessage(8, LogLevel.Information, "Request redirected to HTTPS", EventName = "RedirectedToHttps")] 34[LoggerMessage(13, LogLevel.Information, "Request redirected to www", EventName = "RedirectedToWww")] 37[LoggerMessage(14, LogLevel.Information, "Request redirected to root domain from www subdomain", EventName = "RedirectedToNonWww")] 39[LoggerMessage(9, LogLevel.Information, "Request was redirected to {redirectedUrl}", EventName = "RedirectedRequest")] 42[LoggerMessage(10, LogLevel.Information, "Request was rewritten to {rewrittenUrl}", EventName = "RewritetenRequest")]

LoggerMessage.g.cs (22)

EndpointMiddleware.cs (3)

62if (!_logger.IsEnabled(LogLevel.Information)) 131[LoggerMessage(0, LogLevel.Information, "Executing endpoint '{EndpointName}'", EventName = "ExecutingEndpoint")] 134[LoggerMessage(1, LogLevel.Information, "Executed endpoint '{EndpointName}'", EventName = "ExecutedEndpoint")]

EndpointRoutingMiddleware.cs (4)

188if (!_logger.IsEnabled(LogLevel.Information)) 354[LoggerMessage(4, LogLevel.Information, "The endpoint '{EndpointName}' is being executed without running additional middleware.", EventName = "ExecutingEndpoint")] 357[LoggerMessage(5, LogLevel.Information, "The endpoint '{EndpointName}' has been executed without running additional middleware.", EventName = "ExecutedEndpoint")] 360[LoggerMessage(6, LogLevel.Information, "The endpoint '{EndpointName}' is being short circuited without running additional middleware or producing a response.", EventName = "ShortCircuitedEndpoint")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (10)

MessagePump.Log.cs (2)

54[LoggerMessage(LoggerEventIds.StopCancelled, LogLevel.Information, "Canceled, terminating {OutstandingRequests} request(s).", EventName = "StopCancelled")] 57[LoggerMessage(LoggerEventIds.WaitingForRequestsToDrain, LogLevel.Information, "Stopping, waiting for {OutstandingRequests} request(s) to drain.", EventName = "WaitingForRequestsToDrain")]

NativeInterop\RequestQueue.cs (1)

210[LoggerMessage(LoggerEventIds.AttachedToQueue, LogLevel.Information, "Attached to an existing request queue '{RequestQueueName}', some options do not apply.", EventName = "AttachedToQueue")]

NativeInterop\UrlGroup.Log.cs (1)

21[LoggerMessage(LoggerEventIds.UnregisteringPrefix, LogLevel.Information, "Stop listening on prefix: {UriPrefix}", EventName = "UnregisteringPrefix")]

RequestProcessing\RequestContextLog.cs (1)

16[LoggerMessage(LoggerEventIds.RequestsDrained, LogLevel.Information, "All requests drained.", EventName = "RequestsDrained")]

src\Shared\Http2cat\Http2CatHostedService.cs (3)

68if (_logger.IsEnabled(LogLevel.Information)) 75if (_logger.IsEnabled(LogLevel.Information)) 104if (_logger.IsEnabled(LogLevel.Information))

Internal\AddressBinder.cs (1)

198if (context.Logger.IsEnabled(LogLevel.Information))

Internal\Http\Http1Connection.cs (1)

78_showErrorDetails = Log.IsEnabled(LogLevel.Information);

Internal\Http\HttpProtocol.cs (1)

1424Log.IsEnabled(LogLevel.Information)

Internal\Infrastructure\KestrelTrace.Connections.cs (1)

94[LoggerMessage(34, LogLevel.Information, @"Connection id ""{ConnectionId}"", Request id ""{TraceIdentifier}"": the application aborted the connection.", EventName = "ApplicationAbortedConnection")]

Internal\Infrastructure\KestrelTrace.General.cs (2)

97[LoggerMessage(32, LogLevel.Information, @"Connection id ""{ConnectionId}"", Request id ""{TraceIdentifier}"": the application completed without reading the entire request body.", EventName = "RequestBodyNotEntirelyRead")] 100[LoggerMessage(33, LogLevel.Information, @"Connection id ""{ConnectionId}"", Request id ""{TraceIdentifier}"": automatic draining of the request body timed out after taking over 5 seconds.", EventName = "RequestBodyDrainTimedOut")]

Internal\Infrastructure\KestrelTrace.Http2.cs (1)

123[LoggerMessage(38, LogLevel.Information, @"Connection id ""{ConnectionId}"": HPACK encoding error while encoding headers for stream ID {StreamId}.", EventName = "HPackEncodingError")]

Internal\Infrastructure\KestrelTrace.Http3.cs (1)

98[LoggerMessage(52, LogLevel.Information, @"Connection id ""{ConnectionId}"": QPACK encoding error while encoding headers for stream ID {StreamId}.", EventName = "QPackEncodingError")]

Internal\KestrelServerImpl.cs (3)

102HttpParser = new HttpParser<Http1ParsingHandler>(trace.IsEnabled(LogLevel.Information), serverOptions.DisableHttp1LineFeedTerminators), 355if (Trace.IsEnabled(LogLevel.Information)) 383if (Trace.IsEnabled(LogLevel.Information))

LocalhostListenOptions.cs (2)

49if (context.Logger.IsEnabled(LogLevel.Information)) 63if (context.Logger.IsEnabled(LogLevel.Information))

LoggerMessage.g.cs (22)

Middleware\HttpsConnectionMiddleware.cs (2)

622[LoggerMessage(4, LogLevel.Information, "HTTP/2 over TLS is not supported on Windows versions older than Windows 10 and Windows Server 2016 due to incompatible ciphers or missing ALPN support. Falling back to HTTP/1.1 instead.", 646[LoggerMessage(9, LogLevel.Information, "Certificate with thumbprint {Thumbprint} lacks the subjectAlternativeName (SAN) extension and may not be accepted by browsers.", EventName = "NoSubjectAlternativeName")]

AddressBinderTests.cs (1)

277Assert.Equal(LogLevel.Information, log.LogLevel);

HttpParserTests.cs (1)

1004private IHttpParser<RequestHandler> CreateParser(KestrelTrace log, bool disableHttp1LineFeedTerminators = true) => new HttpParser<RequestHandler>(log.IsEnabled(LogLevel.Information), disableHttp1LineFeedTerminators);

src\Servers\Kestrel\shared\test\TestServiceContext.cs (1)

60HttpParser = new HttpParser<Http1ParsingHandler>(Log.IsEnabled(LogLevel.Information), disableHttp1LineFeedTerminators);

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

DistributedSession.cs (1)

251if (_logger.IsEnabled(LogLevel.Information))

LoggerMessage.g.cs (22)

LoggingExtensions.cs (5)

11[LoggerMessage(2, LogLevel.Information, "Accessing expired session, Key:{sessionKey}", EventName = "AccessingExpiredSession")] 14[LoggerMessage(3, LogLevel.Information, "Session started; Key:{sessionKey}, Id:{sessionId}", EventName = "SessionStarted", SkipEnabledCheck = true)] 35[LoggerMessage(10, LogLevel.Information, "Committing the session was canceled.", EventName = "SessionCommitCanceled")] 41[LoggerMessage(12, LogLevel.Information, "Refreshing the session was canceled.", EventName = "SessionRefreshCanceled")] 44[LoggerMessage(13, LogLevel.Information, "Session cannot be committed since it is unavailable.", EventName = "SessionCommitNotAvailable")]

SessionTests.cs (8)

HubConnection.Log.cs (5)

135[LoggerMessage(24, LogLevel.Information, "Using HubProtocol '{Protocol} v{Version}'.", EventName = "HubProtocol")] 183[LoggerMessage(44, LogLevel.Information, "HubConnection started.", EventName = "Started")] 260[LoggerMessage(68, LogLevel.Information, "HubConnection reconnecting.", EventName = "Reconnecting")] 266[LoggerMessage(70, LogLevel.Information, "HubConnection reconnected successfully after {ReconnectAttempts} attempts and {ElapsedTime} elapsed.", EventName = "Reconnected")] 269[LoggerMessage(71, LogLevel.Information, "Reconnect retries have been exhausted after {ReconnectAttempts} failed attempts and {ElapsedTime} elapsed. Disconnecting.", EventName = "ReconnectAttemptsExhausted")]

LoggerMessage.g.cs (22)

HubConnectionTests.Reconnect.cs (1)

364Assert.Equal(LogLevel.Information, attemptsLog.Write.LogLevel);

LoggerMessage.g.cs (22)

Internal\RedisLog.cs (4)

16if (logger.IsEnabled(LogLevel.Information) && endpoints.Count > 0) 22[LoggerMessage(1, LogLevel.Information, "Connecting to Redis endpoints: {Endpoints}. Using Server Name: {ServerName}", EventName = "ConnectingToEndpoints")] 25[LoggerMessage(2, LogLevel.Information, "Connected to Redis.", EventName = "Connected")] 43[LoggerMessage(8, LogLevel.Information, "Connection to Redis restored.", EventName = "ConnectionRestored")]

LoggerMessage.g.cs (22)

SpaProxyLaunchManager.cs (2)

45if (_logger.IsEnabled(LogLevel.Information)) 163else if (_logger.IsEnabled(LogLevel.Information))

SpaProxyMiddleware.cs (1)

67if (_logger.IsEnabled(LogLevel.Information))

AngularCli\AngularCliMiddleware.cs (1)

62if (logger.IsEnabled(LogLevel.Information))

Npm\NodeScriptRunner.cs (1)

89if (!string.IsNullOrWhiteSpace(line) && logger.IsEnabled(LogLevel.Information))

ReactDevelopmentServer\ReactDevelopmentServerMiddleware.cs (1)

68if (logger.IsEnabled(LogLevel.Information))

LoggerExtensions.cs (4)

14[LoggerMessage(2, LogLevel.Information, "Sending file. Request path: '{VirtualPath}'. Physical path: '{PhysicalPath}'", EventName = "FileServed")] 38[LoggerMessage(6, LogLevel.Information, "The file {Path} was not modified", EventName = "FileNotModified")] 41[LoggerMessage(7, LogLevel.Information, "Precondition for {Path} failed", EventName = "PreconditionFailed")] 50[LoggerMessage(10, LogLevel.Information, "Sending {Range} of file {Path}", EventName = "SendingFileRange")]

LoggerMessage.g.cs (22)

LoggerExtensions.cs (4)

17[LoggerMessage(2, LogLevel.Information, "Sending file. Request path: '{VirtualPath}'. Physical path: '{PhysicalPath}'", EventName = "FileServed")] 41[LoggerMessage(6, LogLevel.Information, "The file {Path} was not modified", EventName = "FileNotModified")] 44[LoggerMessage(7, LogLevel.Information, "Precondition for {Path} failed", EventName = "PreconditionFailed")] 53[LoggerMessage(10, LogLevel.Information, "Sending {Range} of file {Path}", EventName = "SendingFileRange")]

LoggerMessage.g.cs (22)

LoggerMessage.g.cs (22)

Logging\LspLogMessageLogger.cs (1)

100LogLevel.Information => MessageType.Info,

Program.cs (1)

305LogConfiguration: new LogConfiguration(logLevel ?? LogLevel.Information),

Testing\RunTestsHandler.cs (1)

163Microsoft.Extensions.Logging.LogLevel.Information => TraceLevel.Info,

Utilities\AbstractLanguageServerClientTests.TestLspClient.cs (1)

179MessageType.Info => LogLevel.Information,

src\MSBuildLogger.cs (1)

34case LogLevel.Information:

ChatCompletion\FunctionInvokingChatClientTests.cs (1)

1037[InlineData(LogLevel.Information)]

ChatCompletion\LoggingChatClientTests.cs (2)

46[InlineData(LogLevel.Information)] 94[InlineData(LogLevel.Information)]

Embeddings\LoggingEmbeddingGeneratorTests.cs (1)

45[InlineData(LogLevel.Information)]

Image\LoggingImageGeneratorTests.cs (2)

46[InlineData(LogLevel.Information)] 97[InlineData(LogLevel.Information)]

SpeechToText\LoggingSpeechToTextClientTests.cs (2)

48[InlineData(LogLevel.Information)] 97[InlineData(LogLevel.Information)]

LoggerMessage.g.cs (22)

Log.cs (6)

14[LoggerMessage(0, LogLevel.Information, "Starting to process files in directory '{directory}' with search pattern '{searchPattern}' and search option '{searchOption}'.")] 17[LoggerMessage(1, LogLevel.Information, "Processing {fileCount} files.")] 20[LoggerMessage(2, LogLevel.Information, "Reading file '{filePath}' using '{reader}'.")] 23[LoggerMessage(3, LogLevel.Information, "Read document '{documentId}'.")] 26[LoggerMessage(4, LogLevel.Information, "Writing chunks using {writer}.")] 29[LoggerMessage(5, LogLevel.Information, "Wrote chunks for document '{documentId}'.")]

LoggerMessage.g.cs (22)

Windows\Log.cs (2)

10[LoggerMessage(1, LogLevel.Information, "Resource Monitoring is running inside a Job Object. For more information about Job Objects see https://aka.ms/job-objects")] 13[LoggerMessage(2, LogLevel.Information, "Resource Monitoring is running outside of Job Object. For more information about Job Objects see https://aka.ms/job-objects")]

Logging\FakeLogRecord.cs (1)

136LogLevel.Information => " info",

Logging\FakeLoggerTests.cs (4)

35Assert.Equal(LogLevel.Information, records[0].Level); 151Assert.True(logger.IsEnabled(LogLevel.Information)); 162Assert.True(logger.IsEnabled(LogLevel.Information)); 319: [(NotIgnoredMessage1, LogLevel.Information, "info] "), (NotIgnoredMessage2, LogLevel.Error, "error] ")];

Internal\ConsoleLifetime.cs (1)

102if (Logger.IsEnabled(LogLevel.Information))

SystemdLifetime.cs (1)

95if (Logger.IsEnabled(LogLevel.Information))

HostTerminatorService.cs (1)

66[LoggerMessage(1, LogLevel.Information, "Debugger is attached. The host won't be automatically disposed.")]

WindowsServiceLifetime.cs (1)

80if (Logger.IsEnabled(LogLevel.Information))

Logging\LogHelper.cs (7)

36LogLevel.Information, 42LogLevel.Information, 47LogLevel.Information, 54LogLevel.Information, 59LogLevel.Information, 64LogLevel.Information, 71if (logger.IsEnabled(LogLevel.Information))

Logging\Internal\HttpClientLogger.cs (2)

83Log.OutgoingRequest(_logger, LogLevel.Information, logRecord); 147return LogLevel.Information;

Logging\AcceptanceTests.cs (2)

45Assert.Equal(LogLevel.Information, logRecord.Level); 86Assert.Equal(LogLevel.Information, secondLogRecord.Level);

Logging\HttpClientLoggerTest.cs (2)

944[InlineData(399, LogLevel.Information)] 949[InlineData(600, LogLevel.Information)]

LoggerMessage.g.cs (22)

Logger.cs (1)

246LogLevel.Information,

LoggingServiceCollectionExtensions.cs (1)

42new DefaultLoggerLevelConfigureOptions(LogLevel.Information)));

src\libraries\Common\src\Extensions\Logging\DebuggerDisplayFormatting.cs (1)

39LogLevel.Information,

LoggerExtensions.cs (4)

172logger.Log(LogLevel.Information, eventId, exception, message, args); 189logger.Log(LogLevel.Information, eventId, message, args); 206logger.Log(LogLevel.Information, exception, message, args); 222logger.Log(LogLevel.Information, message, args);

src\libraries\Common\src\Extensions\Logging\DebuggerDisplayFormatting.cs (1)

39LogLevel.Information,

ConfigurationBasedLevelSwitcher.cs (1)

42return LogLevel.Information;

ConsoleLoggerExtensions.Obsolete.cs (2)

55factory.AddConsole((n, l) => l >= LogLevel.Information, includeScopes); 83factory.AddConsole((n, l) => l >= LogLevel.Information, includeScopes);

JsonConsoleFormatter.cs (1)

125LogLevel.Information => "Information",

SimpleConsoleFormatter.cs (3)

16private static readonly string _messagePadding = new string(' ', GetLogLevelString(LogLevel.Information).Length + LoglevelPadding.Length); 169LogLevel.Information => "info", 193LogLevel.Information => new ConsoleColors(ConsoleColor.DarkGreen, ConsoleColor.Black),

SystemdConsoleFormatter.cs (1)

127LogLevel.Information => "<6>", // informational messages

EventLoggerFactoryExtensions.cs (1)

51public static ILoggerFactory AddEventLog(this ILoggerFactory factory) => AddEventLog(factory, LogLevel.Information);

EventLogLogger.cs (1)

189case LogLevel.Information:

LoggingEventSource.cs (2)

498ret = LogLevel.Information; 536return LogLevel.Information;

TraceSourceLogger.cs (1)

75case LogLevel.Information: return TraceEventType.Information;

ModelLoaders\FileModelLoader.cs (1)

175LogLevel.Information,

Buffering\GlobalBufferLoggerBuilderExtensionsTests.cs (5)

48new ("Program.MyLogger", LogLevel.Information, 1, "number one", [new("region", "westus2"), new ("priority", 1)]), 49new (logLevel: LogLevel.Information), 78new(categoryName: "Program.MyLogger", logLevel: LogLevel.Information, eventId: 1, eventName: "number one"), 79new(logLevel : LogLevel.Information), 83new(logLevel: LogLevel.Information),

Buffering\GlobalLogBufferingConfigureOptionsTests.cs (1)

93Assert.Equal(LogLevel.Information, options.Rules[0].LogLevel);

Buffering\LogBufferingFilterRuleTests.cs (4)

23new LogBufferingFilterRule(logLevel: LogLevel.Information, eventId: 1), 24new LogBufferingFilterRule(logLevel: LogLevel.Information, eventId: 1), 59new LogBufferingFilterRule(logLevel: LogLevel.Information, eventId: 1), 60new LogBufferingFilterRule(logLevel: LogLevel.Information, eventId: 1),

Logging\ExtendedLoggerTests.cs (1)

417logger.Log(LogLevel.Information, new EventId(0, "ID0"), "PAYLOAD", null, (_, _) => "MSG0");

Sampling\LogSamplingRuleSelectorTests.cs (9)

Sampling\RandomProbabilisticSamplerTests.cs (3)

48options.Rules.Add(new RandomProbabilisticSamplerFilterRule(probability: Probability, logLevel: LogLevel.Information)); 64LogLevel.Information, nameof(WhenParametersMatch_UsesProvidedProbability), 0, _dummyState, _dummyException, _dummyFormatter); 66options.Rules.Add(new RandomProbabilisticSamplerFilterRule(probability: Probability, logLevel: LogLevel.Information));

Sampling\SamplingLoggerBuilderExtensionsTests.cs (8)

LoggerMessageAttributeTests.cs (2)

149new NonStaticTestClass(logger).M3(LogLevel.Information, "arg_0"); 150AssertWhenDefaultLogMethodCtor(collector, LogLevel.Information, ("p0", "-----"));

LogMethodTests.cs (11)

LogPropertiesRedactionTests.cs (2)

52instance.DefaultAttrCtorLogPropertiesWithRedaction(LogLevel.Information, "arg0", classToRedact); 56Assert.Equal(LogLevel.Information, collector.LatestRecord.Level);

LogPropertiesTests.cs (5)

302Assert.Equal(LogLevel.Information, _logger.Collector.LatestRecord.Level); 323Assert.Equal(LogLevel.Information, _logger.Collector.LatestRecord.Level); 343Assert.Equal(LogLevel.Information, _logger.Collector.LatestRecord.Level); 365Assert.Equal(LogLevel.Information, latestRecord.Level); 501Assert.Equal(LogLevel.Information, latestRecord.Level);

TagProviderTests.cs (2)

57Assert.Equal(LogLevel.Information, latestRecord.Level); 290Assert.Equal(LogLevel.Information, latestRecord.Level);

test\Generators\Microsoft.Gen.Logging\TestClasses\AtSymbolsTestExtensions.cs (5)

18[LoggerMessage(0, LogLevel.Information, "M0 {event}")] 21[LoggerMessage(1, LogLevel.Information, "M1 {@myevent1}")] 36[LoggerMessage(LogLevel.Information, "M4 {class}")] 42[LoggerMessage(LogLevel.Information, "M6 class {class}")] 45[LoggerMessage(LogLevel.Information, "M7 param {@param}")]

test\Generators\Microsoft.Gen.Logging\TestClasses\InParameterTestExtensions.cs (1)

15[LoggerMessage(0, LogLevel.Information, "M0 {s}")]

test\Generators\Microsoft.Gen.Logging\TestClasses\LevelTestExtensions.cs (1)

16[LoggerMessage(2, LogLevel.Information, "M2")]

test\Generators\Microsoft.Gen.Logging\TestClasses\LogPropertiesExtensions.cs (7)

228[LoggerMessage(1, LogLevel.Information, "Both {StringProperty} and {ComplexParam} as params")] 231[LoggerMessage(2, LogLevel.Information, "Testing non-nullable struct here...")] 234[LoggerMessage(3, LogLevel.Information, "Testing nullable struct here...")] 237[LoggerMessage(4, LogLevel.Information, "Testing explicit nullable struct here...")] 240[LoggerMessage(5, LogLevel.Information, "Testing nullable property within class here...")] 246[LoggerMessage(6, LogLevel.Information, "Testing interface-typed argument here...")] 249[LoggerMessage(7, LogLevel.Information, "Testing logging a complex object residing in another assembly...")]

test\Generators\Microsoft.Gen.Logging\TestClasses\LogPropertiesRedactionExtensions.cs (1)

58[LoggerMessage(2, LogLevel.Information, "Only {StringProperty} as param")]

test\Generators\Microsoft.Gen.Logging\TestClasses\NonSensitiveRecordExtensions.cs (1)

20[LoggerMessage(6001, LogLevel.Information, "Logging User: {User}")]

test\Generators\Microsoft.Gen.Logging\TestClasses\NonStaticTestClass.cs (3)

31[LoggerMessage(4, LogLevel.Information, "LogProperties: {P0}")] 34[LoggerMessage(5, LogLevel.Information, "LogProperties with provider: {P0}, {P1}")] 39[LoggerMessage(6, LogLevel.Information, "LogProperties with redaction: {P0}")]

test\Generators\Microsoft.Gen.Logging\TestClasses\OriginalFormatTestExtensions.cs (4)

10[LoggerMessage(0, LogLevel.Information, "M0")] 13[LoggerMessage(1, LogLevel.Information, "M1 {p0}")] 16[LoggerMessage(2, LogLevel.Information, "M2 {p0}{p1}")] 19[LoggerMessage(LogLevel.Information)]

test\Generators\Microsoft.Gen.Logging\TestClasses\OverloadsTestExtensions.cs (2)

10[LoggerMessage(0, LogLevel.Information, "M0 {v}", EventName = "One")] 13[LoggerMessage(1, LogLevel.Information, "M0 {v}", EventName = "Two")]

test\Generators\Microsoft.Gen.Logging\TestClasses\SensitiveRecordExtensions.cs (3)

75[LoggerMessage(LogLevel.Information, "Data was obtained")] 80[LoggerMessage(LogLevel.Information)] 85[LoggerMessage(LogLevel.Information, "Data is {data}")]

test\Generators\Microsoft.Gen.Logging\TestClasses\SkipEnabledCheckTestExtensions.cs (2)

10[LoggerMessage(0, LogLevel.Information, "M0", SkipEnabledCheck = true)] 13[LoggerMessage(1, LogLevel.Information, "M1", SkipEnabledCheck = false)]

test\Generators\Microsoft.Gen.Logging\TestClasses\TagProviderExtensions.cs (1)

24[LoggerMessage(LogLevel.Information, "Custom provided properties for interface.")]

test\Generators\Microsoft.Gen.Logging\TestClasses\TransitiveTestExtensions.cs (1)

46[LoggerMessage(LogLevel.Information)]

Program.cs (1)

18factory.AddFilter("Console", level => level >= LogLevel.Information);

src\Servers\Kestrel\shared\test\TestServiceContext.cs (1)

60HttpParser = new HttpParser<Http1ParsingHandler>(Log.IsEnabled(LogLevel.Information), disableHttp1LineFeedTerminators);

src\Servers\Kestrel\test\BindTests\AddressRegistrationTests.cs (1)

637Assert.Single(LogMessages, log => log.LogLevel == LogLevel.Information &&

src\Servers\Kestrel\shared\test\TestServiceContext.cs (1)

60HttpParser = new HttpParser<Http1ParsingHandler>(Log.IsEnabled(LogLevel.Information), disableHttp1LineFeedTerminators);

src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (1)

458Assert.DoesNotContain(coreLogs, w => w.LogLevel > LogLevel.Information);

Program.cs (1)

231logger.Log(LogLevel.Information, 0, eventData, null, formatter: (_, _) => null!);

src\ProjectTemplates\Shared\AspNetProcess.cs (2)

80if (logger is not null && logger.IsEnabled(LogLevel.Information)) 99if (logger is not null && logger.IsEnabled(LogLevel.Information))

src\ProjectTemplates\Shared\TestOutputLogger.cs (1)

26if (_logger.IsEnabled(LogLevel.Information))

src\ProjectTemplates\Shared\AspNetProcess.cs (2)

80if (logger is not null && logger.IsEnabled(LogLevel.Information)) 99if (logger is not null && logger.IsEnabled(LogLevel.Information))

src\ProjectTemplates\Shared\TestOutputLogger.cs (1)

26if (_logger.IsEnabled(LogLevel.Information))

src\ProjectTemplates\Shared\AspNetProcess.cs (2)

80if (logger is not null && logger.IsEnabled(LogLevel.Information)) 99if (logger is not null && logger.IsEnabled(LogLevel.Information))

src\ProjectTemplates\Shared\TestOutputLogger.cs (1)

26if (_logger.IsEnabled(LogLevel.Information))

src\ProjectTemplates\Shared\AspNetProcess.cs (2)

80if (logger is not null && logger.IsEnabled(LogLevel.Information)) 99if (logger is not null && logger.IsEnabled(LogLevel.Information))

src\ProjectTemplates\Shared\TestOutputLogger.cs (1)

26if (_logger.IsEnabled(LogLevel.Information))

src\ProjectTemplates\Shared\AspNetProcess.cs (2)

80if (logger is not null && logger.IsEnabled(LogLevel.Information)) 99if (logger is not null && logger.IsEnabled(LogLevel.Information))

src\ProjectTemplates\Shared\TestOutputLogger.cs (1)

26if (_logger.IsEnabled(LogLevel.Information))

Worker.cs (1)

21if (_logger.IsEnabled(LogLevel.Information))

Program.cs (2)

35factory.AddFilter("Console", level => level >= LogLevel.Information); 36factory.AddFilter("Debug", level => level >= LogLevel.Information);