Trace

Backchannel\AppHostCliBackchannel.cs (1)

325var connectingLogLevel = retryCount % 10 == 0 ? LogLevel.Debug : LogLevel.Trace;

Commands\PipelineCommandBase.cs (3)

763LogLevel.Debug or LogLevel.Trace => $"[[{timestamp}]] [dim][[{logPrefix}]] {message}[/]", 896case LogLevel.Trace: 1354"TRACE" => (LogLevel.Trace, "TRC"),

Commands\RunCommand.cs (1)

1250if (extensionInteractionService is null || entry.LogLevel is LogLevel.Trace or LogLevel.Debug)

Diagnostics\CliLogFormat.cs (2)

52LogLevel.Trace => FileLevelTokens.Trace, 75FileLevelTokens.Trace => LogLevel.Trace,

DotNet\ProcessExecution.cs (2)

576if (_logger.IsEnabled(LogLevel.Trace)) 587if (_logger.IsEnabled(LogLevel.Trace))

Program.cs (1)

277consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;

Acquisition\PeerInstallProbeTests.cs (1)

24private readonly ILoggerFactory _loggerFactory = LoggerFactory.Create(builder => builder.AddXunit(outputHelper, LogLevel.Trace));

Diagnostics\CliLogFormatTests.cs (1)

52[InlineData(CliLogFormat.FileLevelTokens.Trace, LogLevel.Trace)]

Interaction\ConsoleInteractionServiceTests.cs (1)

356[InlineData(LogLevel.Trace)]

Interaction\SpectreConsoleLoggerProviderTests.cs (1)

36Assert.False(aspireLogger.IsEnabled(LogLevel.Trace));

tests\Shared\Logging\XunitLoggerProvider.cs (1)

17: this(output, LogLevel.Trace)

Utils\CliTestHelper.cs (1)

120services.AddLogging(b => b.SetMinimumLevel(LogLevel.Trace)).AddXunitLogging(outputHelper);

Api\TelemetryApiService.cs (2)

194if (logLevel != LogLevel.Trace) 305if (parsedLevel != LogLevel.Trace)

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

205new() { Id = LogLevel.Trace, Name = "Trace" },

Model\StructuredLogsViewModel.cs (1)

115if (logLevel != null && logLevel != Microsoft.Extensions.Logging.LogLevel.Trace)

Otlp\Model\OtlpLogEntryData.cs (1)

97SeverityNumberProto.Trace or SeverityNumberProto.Trace2 or SeverityNumberProto.Trace3 or SeverityNumberProto.Trace4 => LogLevel.Trace,

Shared\IntegrationTestHelpers.cs (2)

16builder.AddXunit(testOutputHelper, LogLevel.Trace, DateTimeOffset.UtcNow); 17builder.SetMinimumLevel(LogLevel.Trace);

tests\Shared\Logging\XunitLoggerProvider.cs (1)

17: this(output, LogLevel.Trace)

Integration\IntegrationTestHelpers.cs (3)

30builder.AddXunit(testOutputHelper, LogLevel.Trace, DateTimeOffset.UtcNow); 31builder.SetMinimumLevel(LogLevel.Trace); 148builder.SetMinimumLevel(LogLevel.Trace);

Integration\StartupTests.cs (9)

623Assert.Single(options.Value.Rules, r => r.CategoryName is null && r.LogLevel == LogLevel.Trace); 624Assert.Single(options.Value.Rules, r => r.CategoryName == "Grpc" && r.LogLevel == LogLevel.Trace); 625Assert.Single(options.Value.Rules, r => r.CategoryName == "Microsoft.Hosting.Lifetime" && r.LogLevel == LogLevel.Trace); 642["Default"] = nameof(LogLevel.Trace), 643["Grpc"] = nameof(LogLevel.Trace), 644["Microsoft.Hosting.Lifetime"] = nameof(LogLevel.Trace) 665Assert.Single(options.Value.Rules, r => r.CategoryName is null && r.LogLevel == LogLevel.Trace); 666Assert.Single(options.Value.Rules, r => r.CategoryName == "Grpc" && r.LogLevel == LogLevel.Trace); 667Assert.Single(options.Value.Rules, r => r.CategoryName == "Microsoft.Hosting.Lifetime" && r.LogLevel == LogLevel.Trace);

Model\DashboardClientTests.cs (2)

28builder.AddXunit(testOutputHelper, LogLevel.Trace, DateTimeOffset.UtcNow); 29builder.SetMinimumLevel(LogLevel.Trace);

Model\StructuredLogsPageViewModelTests.cs (2)

74vm.SelectedLogEntry = await CreateLogDetailsViewModelAsync(repositoryContext.Repository, LogLevel.Trace, "any message"); 227LogLevel.Trace => SeverityNumber.Trace,

TelemetryRepositoryTests\TelemetryRepositoryTests.cs (1)

181b.SetMinimumLevel(LogLevel.Trace);

tests\Shared\Logging\XunitLoggerProvider.cs (1)

17: this(output, LogLevel.Trace)

ApplicationModel\ResourceNotificationService.cs (2)

873if (_logger.IsEnabled(LogLevel.Trace)) 905if (_logger.IsEnabled(LogLevel.Trace))

Ats\LoggingExports.cs (1)

125"trace" => LogLevel.Trace,

Dcp\DcpHost.cs (2)

490var appHostLogLevel = logLevel == LogLevel.Trace ? LogLevel.Trace : LogLevel.Debug;

Dcp\DcpLogParser.cs (1)

112logLevel = LogLevel.Trace;

Dcp\DcpResourceWatcher.cs (4)

299if (_logger.IsEnabled(LogLevel.Trace)) 306if (_logger.IsEnabled(LogLevel.Trace)) 370if (_logger.IsEnabled(LogLevel.Trace)) 1016if (_logger.IsEnabled(LogLevel.Trace))

DistributedApplicationBuilder.cs (1)

620"trace" => LogLevel.Trace,

Orchestrator\ApplicationOrchestrator.cs (17)

BrowserLogsEventLogger.cs (1)

253case LogLevel.Trace:

src\Aspire.Hosting.Browsers\BrowserLogsEventLogger.cs (1)

253case LogLevel.Trace:

EFCoreOperationExecutor.cs (2)

476return (LogLevel.Trace, remainder, false); 483return (isErrorMessage ? LogLevel.Error : LogLevel.Trace, content, false);

RemoteHostServerTests.cs (1)

23Assert.True(logger.IsEnabled(LogLevel.Trace));

tests\Shared\DistributedApplicationTestingBuilderExtensions.cs (1)

34builder.AddFilter("Aspire.Hosting", LogLevel.Trace);

tests\Shared\Logging\XunitLoggerProvider.cs (1)

17: this(output, LogLevel.Trace)

Dashboard\DashboardEventHandlersTests.cs (1)

37b.SetMinimumLevel(LogLevel.Trace);

Dashboard\DashboardResourceTests.cs (1)

687[InlineData(LogLevel.Trace)]

Dashboard\DashboardServiceTests.cs (6)

145builder.SetMinimumLevel(LogLevel.Trace); 464builder.SetMinimumLevel(LogLevel.Trace); 535builder.SetMinimumLevel(LogLevel.Trace); 583builder.SetMinimumLevel(LogLevel.Trace); 643builder.SetMinimumLevel(LogLevel.Trace); 681builder.SetMinimumLevel(LogLevel.Trace);

Dcp\DcpLogParserTests.cs (2)

121Assert.Equal(LogLevel.Trace, logLevel); 252[InlineData("trace", LogLevel.Trace)]

DistributedApplicationBuilderTests.cs (3)

195[LogLevel.Trace, LogLevel.Trace], 258Assert.True(logger.IsEnabled(LogLevel.Trace));

ResourceNotificationTests.cs (4)

988Assert.Equal(3, logs.Where(l => l.Level == LogLevel.Trace).Count()); 989Assert.Contains(logs, l => l.Level == LogLevel.Trace && l.Message.Contains("Resource resource1/resource1 update published:") && l.Message.Contains($"CreationTimeStamp = {createdDate:s}")); 990Assert.Contains(logs, l => l.Level == LogLevel.Trace && l.Message.Contains("Resource resource1/resource1 update published:") && l.Message.Contains("State = { Text = SomeState")); 991Assert.Contains(logs, l => l.Level == LogLevel.Trace && l.Message.Contains("Resource resource1/resource1 update published:") && l.Message.Contains("ExitCode = 0"));

tests\Shared\DistributedApplicationTestingBuilderExtensions.cs (1)

34builder.AddFilter("Aspire.Hosting", LogLevel.Trace);

tests\Shared\Logging\XunitLoggerProvider.cs (1)

17: this(output, LogLevel.Trace)

BlazorWasmHostingTests.cs (2)

212logging.SetMinimumLevel(LogLevel.Trace); 213logging.AddFilter("Aspire", LogLevel.Trace);

Infrastructure\DistributedApplicationTestFactory.cs (3)

43logging.SetMinimumLevel(LogLevel.Trace); 44logging.AddFilter("Aspire", LogLevel.Trace); 45logging.AddFilter(builder.Environment.ApplicationName, LogLevel.Trace);

tests\Shared\Logging\XunitLoggerProvider.cs (1)

17: this(output, LogLevel.Trace)

CodeFormatter.cs (1)

30var logWorkspaceWarnings = formatOptions.LogLevel == LogLevel.Trace;

Commands\FormatCommandCommon.cs (1)

292"diag" or "diagnostic" => LogLevel.Trace,

Logging\SimpleConsoleLogger.cs (1)

27[LogLevel.Trace] = ConsoleColor.Gray,

CommandLine\CommandLineOptions.cs (1)

149? LogLevel.Trace

CompactConsoleLoggerFormatter.cs (2)

106LogLevel.Trace => "trce", 126LogLevel.Trace => (ConsoleColor.Gray, ConsoleColor.Black),

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (20)

LoggingExtensions.cs (10)

14[LoggerMessage(27, LogLevel.Trace, "Authorization code received.", EventName = "AuthorizationCodeReceived")] 17[LoggerMessage(30, LogLevel.Trace, "Token response received.", EventName = "TokenResponseReceived")] 50[LoggerMessage(24, LogLevel.Trace, "MessageReceived: '{RedirectUrl}'.", EventName = "MessageReceived")] 107[LoggerMessage(20, LogLevel.Trace, "Retrieving claims from the user info endpoint.", EventName = "RetrievingClaims")] 128[LoggerMessage(9, LogLevel.Trace, "Entering {OpenIdConnectHandlerType}'s HandleRemoteAuthenticateAsync.", EventName = "EnteringOpenIdAuthenticationHandlerHandleRemoteAuthenticateAsync")] 131[LoggerMessage(4, LogLevel.Trace, "Entering {OpenIdConnectHandlerType}'s HandleUnauthorizedAsync.", EventName = "EnteringOpenIdAuthenticationHandlerHandleUnauthorizedAsync")] 134[LoggerMessage(14, LogLevel.Trace, "Entering {OpenIdConnectHandlerType}'s HandleSignOutAsync.", EventName = "EnteringOpenIdAuthenticationHandlerHandleSignOutAsync")] 137[LoggerMessage(35, LogLevel.Trace, "User information received: {User}", EventName = "UserInformationReceived")] 140[LoggerMessage(5, LogLevel.Trace, "Using properties.RedirectUri for 'local redirect' post authentication: '{RedirectUri}'.", EventName = "PostAuthenticationLocalRedirect")] 143[LoggerMessage(33, LogLevel.Trace, "Using properties.RedirectUri for redirect post authentication: '{RedirectUri}'.", EventName = "PostSignOutRedirect")]

ComponentHub.cs (3)

658if (!logger.IsEnabled(LogLevel.Trace)) 675if (!logger.IsEnabled(LogLevel.Trace)) 686if (!logger.IsEnabled(LogLevel.Trace))

Services\WebAssemblyConsoleLogger.cs (2)

72case LogLevel.Trace: 142case LogLevel.Trace:

Services\RemoteAuthenticationService.cs (1)

82TraceEnabled = logger?.IsEnabled(LogLevel.Trace) ?? false

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (4)

LoggingExtensions.cs (2)

8[LoggerMessage(1, LogLevel.Trace, "Needs consent: {needsConsent}.", EventName = "NeedsConsent")] 11[LoggerMessage(2, LogLevel.Trace, "Has consent: {hasConsent}.", EventName = "HasConsent")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (14)

LoggingExtensions.cs (8)

34return IsLogLevelEnabledCore(logger, LogLevel.Trace); 55[LoggerMessage(5, LogLevel.Trace, "Performing unprotect operation to key {KeyId:B} with purposes {Purposes}.", EventName = "PerformingUnprotectOperationToKeyWithPurposes")] 58[LoggerMessage(6, LogLevel.Trace, "Key {KeyId:B} was not found in the key ring. Unprotect operation cannot proceed.", EventName = "KeyWasNotFoundInTheKeyRingUnprotectOperationCannotProceed")] 115[LoggerMessage(25, LogLevel.Trace, "An exception occurred while processing the key element '{Element}'.", EventName = "ExceptionOccurredWhileProcessingTheKeyElementDebug")] 130[LoggerMessage(31, LogLevel.Trace, "Performing protect operation to key {KeyId:B} with purposes {Purposes}.", EventName = "PerformingProtectOperationToKeyWithPurposes")] 241[LoggerMessage(61, LogLevel.Trace, "Ignoring configuration '{PropertyName}' for options instance '{OptionsName}'", EventName = "IgnoringReadOnlyConfigurationForNonDefaultOptions")] 271[LoggerMessage(78, LogLevel.Trace, "Found multiple revocation entries for key {KeyId:B}.", EventName = "KeyRevokedMultipleTimes")] 274[LoggerMessage(79, LogLevel.Trace, "Ignoring revocation of keys created before {OlderDate:u} in favor of revocation of keys created before {NewerDate:u}.", EventName = "DateBasedRevocationSuperseded")]

Logging\AcceptanceTests.cs (6)

807LogLevel.Trace, 842Assert.Equal(LogLevel.Trace, logCollector.LatestRecord.Level); 851LogLevel.Trace, 890Assert.Equal(LogLevel.Trace, logCollector.LatestRecord.Level); 899LogLevel.Trace, 947Assert.Equal(LogLevel.Trace, logCollector.LatestRecord.Level);

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (7)

Internal\Binding\JsonTranscodingProviderServiceBinder.cs (2)

126if (_logger.IsEnabled(LogLevel.Trace)) 281[LoggerMessage(3, LogLevel.Trace, "Found HttpRule mapping. Method {MethodName} on {ServiceName}. HttpRule payload: {HttpRulePayload}", EventName = "HttpRuleFound", SkipEnabledCheck = true)]

Internal\GrpcServerLog.cs (3)

23[LoggerMessage(5, LogLevel.Trace, "Deserializing to '{MessageType}'.", EventName = "DeserializingMessage")] 26[LoggerMessage(6, LogLevel.Trace, "Received message.", EventName = "ReceivedMessage")] 41[LoggerMessage(11, LogLevel.Trace, "Serialized '{MessageType}'.", EventName = "SerializedMessage")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (4)

LoggerExtensions.cs (2)

16[LoggerMessage(2, LogLevel.Trace, "All hosts are allowed.", EventName = "AllHostsAllowed")] 25[LoggerMessage(5, LogLevel.Trace, "The host '{Host}' matches an allowed host.", EventName = "AllowedHostMatched")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (44)

Internal\HttpConnectionContext.cs (9)

1166[LoggerMessage(1, LogLevel.Trace, "Disposing connection {TransportConnectionId}.", EventName = "DisposingConnection")] 1169[LoggerMessage(2, LogLevel.Trace, "Waiting for application to complete.", EventName = "WaitingForApplication")] 1172[LoggerMessage(3, LogLevel.Trace, "Application complete.", EventName = "ApplicationComplete")] 1175[LoggerMessage(4, LogLevel.Trace, "Waiting for {TransportType} transport to complete.", EventName = "WaitingForTransport")] 1178[LoggerMessage(5, LogLevel.Trace, "{TransportType} transport complete.", EventName = "TransportComplete")] 1181[LoggerMessage(6, LogLevel.Trace, "Shutting down both the application and the {TransportType} transport.", EventName = "ShuttingDownTransportAndApplication")] 1184[LoggerMessage(7, LogLevel.Trace, "Waiting for both the application and {TransportType} transport to complete.", EventName = "WaitingForTransportAndApplication")] 1187[LoggerMessage(8, LogLevel.Trace, "The application and {TransportType} transport are both complete.", EventName = "TransportAndApplicationComplete")] 1190[LoggerMessage(9, LogLevel.Trace, "{Timeout}ms elapsed attempting to send a message to the transport. Closing connection {TransportConnectionId}.", EventName = "TransportSendTimeout")]

Internal\HttpConnectionDispatcher.Log.cs (4)

18[LoggerMessage(3, LogLevel.Trace, "Previous poll canceled for {TransportConnectionId} on {RequestId}.", EventName = "PollCanceled")] 27[LoggerMessage(6, LogLevel.Trace, "Received {Count} bytes.", EventName = "ReceivedBytes")] 42[LoggerMessage(11, LogLevel.Trace, "Received DELETE request for unsupported transport: {TransportType}.", EventName = "ReceivedDeleteRequestForUnsupportedTransport")] 45[LoggerMessage(12, LogLevel.Trace, "Terminating Long Polling connection due to a DELETE request.", EventName = "TerminatingConection")]

Internal\HttpConnectionManager.Log.cs (4)

21[LoggerMessage(5, LogLevel.Trace, "Connection {TransportConnectionId} timed out.", EventName = "ConnectionTimedOut")] 24[LoggerMessage(4, LogLevel.Trace, "Connection {TransportConnectionId} was reset.", EventName = "ConnectionReset")] 32[LoggerMessage(9, LogLevel.Trace, "Starting connection heartbeat.", EventName = "HeartBeatStarted")] 35[LoggerMessage(10, LogLevel.Trace, "Ending connection heartbeat.", EventName = "HeartBeatEnded")]

Internal\Transports\LongPollingServerTransport.cs (1)

123[LoggerMessage(3, LogLevel.Trace, "Writing a {Count} byte message to connection.", EventName = "LongPollingWritingMessage")]

Internal\Transports\ServerSentEventsServerTransport.cs (1)

90[LoggerMessage(1, LogLevel.Trace, "Writing a {Count} byte message.", EventName = "SSEWritingMessage")]

Internal\Transports\WebSocketsServerTransport.Log.cs (3)

37[LoggerMessage(9, LogLevel.Trace, "Message received. Type: {MessageType}, size: {Size}, EndOfMessage: {EndOfMessage}.", EventName = "MessageReceived")] 40[LoggerMessage(10, LogLevel.Trace, "Passing message to application. Payload size: {Size}.", EventName = "MessageToApplication")] 43[LoggerMessage(11, LogLevel.Trace, "Sending payload: {Size} bytes.", EventName = "SendPayload")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (5)

HttpConnection.Log.cs (1)

106[LoggerMessage(20, LogLevel.Trace, "Cookies are not supported on this platform.", EventName = "CookiesNotSupported")]

Internal\LoggingHttpMessageHandler.cs (1)

41[LoggerMessage(1, LogLevel.Trace, "Sending HTTP request {RequestMethod} '{RequestUrl}'.", EventName = "SendingHttpRequest")]

Internal\LongPollingTransport.Log.cs (2)

46if (logger.IsEnabled(LogLevel.Trace)) 53[LoggerMessage(10, LogLevel.Trace, "Poll response with status code {StatusCode} received from server. Content length: {ContentLength}.", EventName = "PollResponseReceived", SkipEnabledCheck = true)]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (2)

42global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(3, "AddingHstsHeader"), "Adding HSTS header to response.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true }); 51if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))

HstsLoggingExtensions.cs (1)

16[LoggerMessage(3, LogLevel.Trace, "Adding HSTS header to response.", EventName = "AddingHstsHeader")]

AssemblyTestLog.cs (2)

94=> CreateLoggerFactory(output, className, LogLevel.Trace, testName, logStart); 200builder.SetMinimumLevel(LogLevel.Trace);

Logging\XunitLoggerProvider.cs (1)

19: this(output, LogLevel.Trace)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (11)

Infrastructure\ClientErrorResultFilter.cs (1)

60[LoggerMessage(49, LogLevel.Trace, "Replacing {InitialActionResultType} with status code {StatusCode} with {ReplacedActionResultType}.", EventName = "ClientErrorResultFilter")]

Infrastructure\ControllerActionInvoker.cs (3)

383if (_diagnosticListener.IsEnabled() || _logger.IsEnabled(LogLevel.Trace)) 628if (arguments != null && logger.IsEnabled(LogLevel.Trace)) 644[LoggerMessage(102, LogLevel.Trace, "Executing action method {ActionName} with arguments ({Arguments})", EventName = "ActionMethodExecutingWithArguments", SkipEnabledCheck = true)]

Infrastructure\ResourceInvoker.cs (1)

267if (_diagnosticListener.IsEnabled() || _logger.IsEnabled(LogLevel.Trace))

Infrastructure\ResourceInvoker.Log.cs (2)

82[LoggerMessage(5, LogLevel.Trace, "Before executing action result {ActionResult}.", EventName = "BeforeExecutingActionResult")] 90[LoggerMessage(6, LogLevel.Trace, "After executing action result {ActionResult}.", EventName = "AfterExecutingActionResult")]

MvcCoreLoggerExtensions.cs (2)

80[LoggerMessage(52, LogLevel.Trace, "{FilterType}: Before executing {Method} on filter {Filter}.", EventName = "BeforeExecutingMethodOnFilter")] 83[LoggerMessage(53, LogLevel.Trace, "{FilterType}: After executing {Method} on filter {Filter}.", EventName = "AfterExecutingMethodOnFilter")]

Compilation\DefaultViewCompiler.cs (2)

143[LoggerMessage(5, LogLevel.Trace, "Located compiled view for view at path '{Path}'.", EventName = "ViewCompilerLocatedCompiledViewForPath")] 146[LoggerMessage(7, LogLevel.Trace, "Could not find a file for view at path '{Path}'.", EventName = "ViewCompilerCouldNotFindFileAtPath")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (4)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (10)

RuntimeViewCompiler.cs (5)

434[LoggerMessage(5, LogLevel.Trace, "Located compiled view for view at path '{Path}'.")] 437[LoggerMessage(6, LogLevel.Trace, "Invalidating compiled view for view at path '{Path}'.")] 440[LoggerMessage(7, LogLevel.Trace, "Could not find a file for view at path '{Path}'.")] 443[LoggerMessage(8, LogLevel.Trace, "Found file at path '{Path}'.")] 446[LoggerMessage(9, LogLevel.Trace, "Invalidating compiled view at path '{Path}' with a file since the checksum did not match.")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (5)

PageLoggerExtensions.cs (4)

82[LoggerMessage(106, LogLevel.Trace, "Executing handler method {HandlerName} with arguments ({Arguments})", EventName = "HandlerMethodExecutingWithArguments", SkipEnabledCheck = true)] 95if (arguments != null && logger.IsEnabled(LogLevel.Trace)) 144[LoggerMessage(1, LogLevel.Trace, "{FilterType}: Before executing {Method} on filter {Filter}.", EventName = "BeforeExecutingMethodOnFilter")] 147[LoggerMessage(2, LogLevel.Trace, "{FilterType}: After executing {Method} on filter {Filter}.", EventName = "AfterExecutingMethodOnFilter")]

Filters\ValidateAntiforgeryTokenAuthorizationFilter.cs (1)

59[LoggerMessage(2, LogLevel.Trace, "Skipping the execution of current filter as its not the most effective filter implementing the policy {FilterPolicy}.", EventName = "NotMostEffectiveFilter")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (2)

145global::Microsoft.Extensions.Logging.LoggerMessage.Define<global::System.Type>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(2, "NotMostEffectiveFilter"), "Skipping the execution of current filter as its not the most effective filter implementing the policy {FilterPolicy}.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true }); 154if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))

DefaultRequestDecompressionProvider.cs (1)

63[LoggerMessage(1, LogLevel.Trace, "The Content-Encoding header is empty or not specified. Skipping request decompression.", EventName = "NoContentEncoding")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (2)

12global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(1, "NoContentEncoding"), "The Content-Encoding header is empty or not specified. Skipping request decompression.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true }); 21if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (4)

ResponseCompressionLoggingExtensions.cs (2)

16[LoggerMessage(3, LogLevel.Trace, "This request accepts compression.", EventName = "RequestAcceptsCompression")] 25[LoggerMessage(6, LogLevel.Trace, "Response compression is available for this Content-Type.", EventName = "ShouldCompressResponse")]

EndpointRoutingMiddleware.cs (1)

405[LoggerMessage(8, LogLevel.Trace, $"The endpoint does not specify the {nameof(IRequestSizeLimitMetadata)}.", EventName = "RequestSizeLimitMetadataNotFound")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (2)

373global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(8, "RequestSizeLimitMetadataNotFound"), "The endpoint does not specify the IRequestSizeLimitMetadata.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true }); 382if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (6)

HttpSysListener.Log.cs (3)

15[LoggerMessage(LoggerEventIds.ListenerDisposing, LogLevel.Trace, "Disposing the listener.", EventName = "ListenerDisposing")] 24[LoggerMessage(LoggerEventIds.ListenerStarting, LogLevel.Trace, "Starting the listener.", EventName = "ListenerStarting")] 30[LoggerMessage(LoggerEventIds.ListenerStopping, LogLevel.Trace, "Stopping the listener.", EventName = "ListenerStopping")]

Deployers\NginxDeployer.cs (1)

151if (Logger.IsEnabled(LogLevel.Trace))

Deployers\RemoteWindowsDeployer\RemoteWindowsDeployer.cs (1)

181if (Logger.IsEnabled(LogLevel.Trace))

AnyIPListenOptions.cs (1)

32if (context.Logger.IsEnabled(LogLevel.Trace))

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (18)

Internal\CertificatePathWatcherLoggerExtensions.cs (7)

37[LoggerMessage(10, LogLevel.Trace, "Reused existing observer on file watcher for '{Path}'.", EventName = "ReusedObserver")] 40[LoggerMessage(11, LogLevel.Trace, "Added observer to file watcher for '{Path}'.", EventName = "AddedObserver")] 43[LoggerMessage(12, LogLevel.Trace, "Removed observer from file watcher for '{Path}'.", EventName = "RemovedObserver")] 46[LoggerMessage(13, LogLevel.Trace, "File '{Path}' now has {Count} observers.", EventName = "ObserverCount")] 49[LoggerMessage(14, LogLevel.Trace, "Directory '{Directory}' now has watchers on {Count} files.", EventName = "FileCount")] 52[LoggerMessage(15, LogLevel.Trace, "Flagged {Count} observers of '{Path}' as changed.", EventName = "FlaggedObservers")] 55[LoggerMessage(16, LogLevel.Trace, "Ignored event since '{Path}' was unavailable.", EventName = "EventWithoutFile")]

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

39if (_http2Logger.IsEnabled(LogLevel.Trace)) 62if (_http2Logger.IsEnabled(LogLevel.Trace)) 120[LoggerMessage(37, LogLevel.Trace, @"Connection id ""{ConnectionId}"" received {type} frame for stream ID {id} with length {length} and flags {flags}.", EventName = "Http2FrameReceived", SkipEnabledCheck = true)] 132[LoggerMessage(49, LogLevel.Trace, @"Connection id ""{ConnectionId}"" sending {type} frame for stream ID {id} with length {length} and flags {flags}.", EventName = "Http2FrameSending", SkipEnabledCheck = true)]

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

38if (_http3Logger.IsEnabled(LogLevel.Trace)) 46if (_http3Logger.IsEnabled(LogLevel.Trace)) 86[LoggerMessage(46, LogLevel.Trace, @"Connection id ""{ConnectionId}"" received {type} frame for stream ID {id} with length {length}.", EventName = "Http3FrameReceived", SkipEnabledCheck = true)] 89[LoggerMessage(47, LogLevel.Trace, @"Connection id ""{ConnectionId}"" sending {type} frame for stream ID {id} with length {length}.", EventName = "Http3FrameSending", SkipEnabledCheck = true)]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (2)

120global::Microsoft.Extensions.Logging.LoggerMessage.Define(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(9, "ConnectionListenerQueueExited"), "Named pipe listener queue exited.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true }); 129if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Trace))

Internal\NamedPipeLog.cs (1)

83[LoggerMessage(9, LogLevel.Trace, "Named pipe listener queue exited.", EventName = "ConnectionListenerQueueExited")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (2)

205global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(16, "StreamPooled"), "Stream id \"{ConnectionId}\" pooled for reuse.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true }); 218global::Microsoft.Extensions.Logging.LoggerMessage.Define<string>(global::Microsoft.Extensions.Logging.LogLevel.Trace, new global::Microsoft.Extensions.Logging.EventId(17, "StreamReused"), "Stream id \"{ConnectionId}\" reused from pool.", new global::Microsoft.Extensions.Logging.LogDefineOptions() { SkipEnabledCheck = true });

Internal\QuicLog.cs (4)

178[LoggerMessage(16, LogLevel.Trace, @"Stream id ""{ConnectionId}"" pooled for reuse.", EventName = "StreamPooled", SkipEnabledCheck = true)] 183if (logger.IsEnabled(LogLevel.Trace)) 189[LoggerMessage(17, LogLevel.Trace, @"Stream id ""{ConnectionId}"" reused from pool.", EventName = "StreamReused", SkipEnabledCheck = true)] 194if (logger.IsEnabled(LogLevel.Trace))

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (72)

HubConnection.Log.cs (35)

15[LoggerMessage(1, LogLevel.Trace, "Preparing non-blocking invocation of '{Target}', with {ArgumentCount} argument(s).", EventName = "PreparingNonBlockingInvocation")] 18[LoggerMessage(2, LogLevel.Trace, "Preparing blocking invocation '{InvocationId}' of '{Target}', with return type '{ReturnType}' and {ArgumentCount} argument(s).", EventName = "PreparingBlockingInvocation")] 24[LoggerMessage(4, LogLevel.Trace, "Issuing Invocation '{InvocationId}': {ReturnType} {MethodName}({Args}).", EventName = "IssuingInvocation", SkipEnabledCheck = true)] 29if (logger.IsEnabled(LogLevel.Trace)) 81[LoggerMessage(8, LogLevel.Trace, "Received Invocation '{InvocationId}': {MethodName}({Args}).", EventName = "ReceivedInvocation", SkipEnabledCheck = true)] 86if (logger.IsEnabled(LogLevel.Trace)) 99[LoggerMessage(11, LogLevel.Trace, "Shutting down connection.", EventName = "ShutdownConnection")] 105[LoggerMessage(13, LogLevel.Trace, "Removing pending invocation {InvocationId}.", EventName = "RemovingInvocation")] 111[LoggerMessage(15, LogLevel.Trace, "Received StreamItem for Invocation {InvocationId}.", EventName = "ReceivedStreamItem")] 114[LoggerMessage(16, LogLevel.Trace, "Canceling dispatch of StreamItem message for Invocation {InvocationId}. The invocation was canceled.", EventName = "CancelingStreamItem")] 120[LoggerMessage(18, LogLevel.Trace, "Received Completion for Invocation {InvocationId}.", EventName = "ReceivedInvocationCompletion")] 123[LoggerMessage(19, LogLevel.Trace, "Canceling dispatch of Completion message for Invocation {InvocationId}. The invocation was canceled.", EventName = "CancelingInvocationCompletion")] 138[LoggerMessage(25, LogLevel.Trace, "Preparing streaming invocation '{InvocationId}' of '{Target}', with return type '{ReturnType}' and {ArgumentCount} argument(s).", EventName = "PreparingStreamingInvocation")] 141[LoggerMessage(26, LogLevel.Trace, "Resetting keep-alive timer, received a message from the server.", EventName = "ResettingKeepAliveTimer")] 150[LoggerMessage(31, LogLevel.Trace, "Received a ping message.", EventName = "ReceivedPing")] 227[LoggerMessage(42, LogLevel.Trace, "Waiting on Connection Lock in {MethodName} ({FilePath}:{LineNumber}).", EventName = "WaitingOnConnectionLock")] 230[LoggerMessage(20, LogLevel.Trace, "Releasing Connection Lock in {MethodName} ({FilePath}:{LineNumber}).", EventName = "ReleasingConnectionLock")] 233[LoggerMessage(55, LogLevel.Trace, "Unable to send cancellation for invocation '{InvocationId}'. The connection is inactive.", EventName = "UnableToSendCancellation")] 239[LoggerMessage(61, LogLevel.Trace, "Acquired the Connection Lock in order to ping the server.", EventName = "AcquiredConnectionLockForPing")] 242[LoggerMessage(62, LogLevel.Trace, "Skipping ping because a send is already in progress.", EventName = "UnableToAcquireConnectionLockForPing")] 245[LoggerMessage(63, LogLevel.Trace, "Initiating stream '{StreamId}'.", EventName = "StartingStream")] 248[LoggerMessage(64, LogLevel.Trace, "Sending item for stream '{StreamId}'.", EventName = "StreamItemSent")] 251[LoggerMessage(65, LogLevel.Trace, "Stream '{StreamId}' has been canceled by client.", EventName = "CancelingStream")] 254[LoggerMessage(66, LogLevel.Trace, "Sending completion message for stream '{StreamId}'.", EventName = "CompletingStream")] 272[LoggerMessage(72, LogLevel.Trace, "Reconnect attempt number {ReconnectAttempts} will start in {RetryDelay}.", EventName = "AwaitingReconnectRetryDelay")] 275[LoggerMessage(73, LogLevel.Trace, "Reconnect attempt failed.", EventName = "ReconnectAttemptFailed")] 290[LoggerMessage(78, LogLevel.Trace, "Connection stopped during reconnect delay. Done reconnecting.", EventName = "ReconnectingStoppedDueToStateChangeDuringRetryDelay")] 293[LoggerMessage(79, LogLevel.Trace, "Connection stopped during reconnect attempt. Done reconnecting.", EventName = "ReconnectingStoppedDueToStateChangeDuringReconnectAttempt")] 296[LoggerMessage(80, LogLevel.Trace, "The HubConnection is attempting to transition from the {ExpectedState} state to the {NewState} state.", EventName = "AttemptingStateTransition")] 311[LoggerMessage(84, LogLevel.Trace, "Client threw an error for stream '{StreamId}'.", EventName = "ErroredStream")] 320[LoggerMessage(87, LogLevel.Trace, "Completion message for stream '{StreamId}' was not sent because the connection is closed.", EventName = "CompletingStreamNotSent")] 326[LoggerMessage(89, LogLevel.Trace, "Error sending Completion message for stream '{StreamId}'.", EventName = "ErrorSendingStreamCompletion")] 329[LoggerMessage(90, LogLevel.Trace, "Dropping {MessageType} with ID '{InvocationId}'.", EventName = "DroppingMessage")] 332[LoggerMessage(91, LogLevel.Trace, "Received AckMessage with Sequence ID '{SequenceId}'.", EventName = "ReceivedAckMessage")] 335[LoggerMessage(92, LogLevel.Trace, "Received SequenceMessage with Sequence ID '{SequenceId}'.", EventName = "ReceivedSequenceMessage")]

Internal\InvocationRequest.cs (4)

243[LoggerMessage(1, LogLevel.Trace, "Invocation {InvocationId} created.", EventName = "InvocationCreated")] 246[LoggerMessage(2, LogLevel.Trace, "Invocation {InvocationId} disposed.", EventName = "InvocationDisposed")] 249[LoggerMessage(3, LogLevel.Trace, "Invocation {InvocationId} marked as completed.", EventName = "InvocationCompleted")] 252[LoggerMessage(4, LogLevel.Trace, "Invocation {InvocationId} marked as failed.", EventName = "InvocationFailed")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (22)

HubConnectionContext.Log.cs (2)

18[LoggerMessage(3, LogLevel.Trace, "Sent a ping message to the client.", EventName = "SentPing")] 33[LoggerMessage(8, LogLevel.Trace, "Abort callback failed.", EventName = "AbortFailed")]

HubConnectionHandlerLog.cs (1)

16[LoggerMessage(3, LogLevel.Trace, "Abort callback failed.", EventName = "AbortFailed")]

Internal\DefaultHubDispatcherLog.cs (11)

28if (logger.IsEnabled(LogLevel.Trace)) 35[LoggerMessage(6, LogLevel.Trace, "InvocationId {InvocationId}: Streaming result of type '{ResultType}'.", EventName = "StreamingResult", SkipEnabledCheck = true)] 40if (logger.IsEnabled(LogLevel.Trace)) 47[LoggerMessage(7, LogLevel.Trace, "InvocationId {InvocationId}: Sending result of type '{ResultType}'.", EventName = "SendingResult", SkipEnabledCheck = true)] 53[LoggerMessage(9, LogLevel.Trace, "'{HubName}' hub method '{HubMethod}' is bound.", EventName = "HubMethodBound")] 77[LoggerMessage(16, LogLevel.Trace, "Received item for stream '{StreamId}'.", EventName = "ReceivedStreamItem")] 80[LoggerMessage(17, LogLevel.Trace, "Creating streaming parameter channel '{StreamId}'.", EventName = "StartingParameterStream")] 86[LoggerMessage(18, LogLevel.Trace, "Stream '{StreamId}' has been completed by client.", EventName = "CompletingStream")] 112[LoggerMessage(26, LogLevel.Trace, "Dropping {MessageType} with ID '{InvocationId}'.", EventName = "DroppingMessage")] 115[LoggerMessage(27, LogLevel.Trace, "Received AckMessage with Sequence ID '{SequenceId}'.", EventName = "ReceivedAckMessage")] 118[LoggerMessage(28, LogLevel.Trace, "Received SequenceMessage with Sequence ID '{SequenceId}'.", EventName = "ReceivedSequenceMessage")]

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\LoggerMessage.g.cs (8)

Internal\RedisLog.cs (4)

28[LoggerMessage(3, LogLevel.Trace, "Subscribing to channel: {Channel}.", EventName = "Subscribing")] 31[LoggerMessage(4, LogLevel.Trace, "Received message from Redis channel {Channel}.", EventName = "ReceivedFromChannel")] 34[LoggerMessage(5, LogLevel.Trace, "Publishing message to Redis channel {Channel}.", EventName = "PublishToChannel")] 37[LoggerMessage(6, LogLevel.Trace, "Unsubscribing from channel: {Channel}.", EventName = "Unsubscribe")]

Build\BuildReporter.cs (1)

27if (logger.IsEnabled(LogLevel.Trace))

Context\GlobalOptions.cs (1)

21=> environmentOptions.CliContextVerbose && LogLevel != LogLevel.Trace

HotReload\ManagedCodeWorkspace.cs (1)

114if (!_logger.IsEnabled(LogLevel.Trace))

Process\ProjectLauncher.cs (1)

75if (clients.IsManagedAgentSupported && Logger.IsEnabled(LogLevel.Trace))

src\sdk\src\Dotnet.Watch\HotReloadClient\Web\AbstractBrowserRefreshServer.cs (1)

102if (logger.IsEnabled(LogLevel.Trace))

UI\IReporter.cs (4)

242public static readonly MessageDescriptor<(string, ChangeKind, string)> IgnoringChangeInHiddenDirectory = Create<(string, ChangeKind, string)>("Ignoring change in hidden directory '{0}': {1} '{2}'", Emoji.Watch, LogLevel.Trace); 243public static readonly MessageDescriptor<(ChangeKind, string)> IgnoringChangeInOutputDirectory = Create<(ChangeKind, string)>("Ignoring change in output directory: {0} '{1}'", Emoji.Watch, LogLevel.Trace); 244public static readonly MessageDescriptor<(string, ChangeKind, string, string, string)> IgnoringChangeInExcludedFile = Create<(string, ChangeKind, string, string, string)>("Ignoring change in excluded file '{0}': {1}. Path matches {2} glob '{3}' set in '{4}'.", Emoji.Watch, LogLevel.Trace); 276public static readonly MessageDescriptor<string> WatchingFilesForChanges_FilePath = Create<string>("> {0}", Emoji.Watch, LogLevel.Trace);

ChatCompletion\LoggingChatClient.cs (9)

22/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 24/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment. 59if (_logger.IsEnabled(LogLevel.Trace)) 75if (_logger.IsEnabled(LogLevel.Trace)) 105if (_logger.IsEnabled(LogLevel.Trace)) 156if (_logger.IsEnabled(LogLevel.Trace)) 177[LoggerMessage(LogLevel.Trace, "{MethodName} invoked: {Messages}. Options: {ChatOptions}. Metadata: {ChatClientMetadata}.")] 183[LoggerMessage(LogLevel.Trace, "{MethodName} completed: {ChatResponse}.")] 186[LoggerMessage(LogLevel.Trace, "GetStreamingResponseAsync received update: {ChatResponseUpdate}")]

ChatCompletion\LoggingChatClientBuilderExtensions.cs (2)

26/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 28/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment.

Common\FunctionInvocationLogger.cs (2)

17[LoggerMessage(LogLevel.Trace, "Invoking {MethodName}({Arguments}).", SkipEnabledCheck = true)] 23[LoggerMessage(LogLevel.Trace, "{MethodName} invocation completed. Duration: {Duration}. Result: {Result}", SkipEnabledCheck = true)]

Common\FunctionInvocationProcessor.cs (1)

177bool traceLoggingEnabled = _logger.IsEnabled(LogLevel.Trace);

Embeddings\LoggingEmbeddingGenerator.cs (4)

23/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 25/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment. 60if (_logger.IsEnabled(LogLevel.Trace)) 95[LoggerMessage(LogLevel.Trace, "GenerateAsync invoked: {Values}. Options: {EmbeddingGenerationOptions}. Metadata: {EmbeddingGeneratorMetadata}.")]

Embeddings\LoggingEmbeddingGeneratorBuilderExtensions.cs (2)

28/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 30/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment.

Files\LoggingHostedFileClient.cs (18)

26/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 28/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment. 67if (_logger.IsEnabled(LogLevel.Trace)) 83if (_logger.IsEnabled(LogLevel.Trace)) 113if (_logger.IsEnabled(LogLevel.Trace)) 149if (_logger.IsEnabled(LogLevel.Trace)) 165if (_logger.IsEnabled(LogLevel.Trace)) 195if (_logger.IsEnabled(LogLevel.Trace)) 246if (_logger.IsEnabled(LogLevel.Trace)) 268if (_logger.IsEnabled(LogLevel.Trace)) 284if (_logger.IsEnabled(LogLevel.Trace)) 313[LoggerMessage(LogLevel.Trace, "UploadAsync invoked. MediaType: {MediaType}. FileName: {FileName}. Options: {HostedFileOptions}. Metadata: {HostedFileClientMetadata}.")] 316[LoggerMessage(LogLevel.Trace, "DownloadAsync invoked. FileId: {FileId}. Options: {HostedFileOptions}. Metadata: {HostedFileClientMetadata}.")] 319[LoggerMessage(LogLevel.Trace, "GetFileInfoAsync invoked. FileId: {FileId}. Options: {HostedFileOptions}. Metadata: {HostedFileClientMetadata}.")] 322[LoggerMessage(LogLevel.Trace, "ListFilesAsync invoked. Options: {HostedFileOptions}. Metadata: {HostedFileClientMetadata}.")] 325[LoggerMessage(LogLevel.Trace, "DeleteAsync invoked. FileId: {FileId}. Options: {HostedFileOptions}. Metadata: {HostedFileClientMetadata}.")] 331[LoggerMessage(LogLevel.Trace, "{MethodName} completed: {HostedFileResult}.")] 334[LoggerMessage(LogLevel.Trace, "ListFilesAsync received item: {HostedFileContent}")]

Files\LoggingHostedFileClientBuilderExtensions.cs (2)

28/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 30/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment.

Image\LoggingImageGenerator.cs (6)

23/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 25/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment. 65if (_logger.IsEnabled(LogLevel.Trace)) 81if (_logger.IsEnabled(LogLevel.Trace) && response.Contents.All(c => c is not DataContent)) 110[LoggerMessage(LogLevel.Trace, "{MethodName} invoked: Prompt: {Prompt}. Options: {ImageGenerationOptions}. Metadata: {ImageGeneratorMetadata}.")] 116[LoggerMessage(LogLevel.Trace, "{MethodName} completed: {ImageGenerationResponse}.")]

Image\LoggingImageGeneratorBuilderExtensions.cs (2)

29/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 31/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment.

Realtime\LoggingRealtimeClient.cs (2)

17/// When the employed <see cref="ILogger"/> enables <see cref="LogLevel.Trace"/>, the contents of 19/// <see cref="LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment.

Realtime\LoggingRealtimeClientBuilderExtensions.cs (2)

29/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 31/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment.

Realtime\LoggingRealtimeClientSession.cs (7)

23/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 25/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment. 83if (_logger.IsEnabled(LogLevel.Trace)) 166if (_logger.IsEnabled(LogLevel.Trace)) 238[LoggerMessage(LogLevel.Trace, "{MethodName} invoked: Options: {Options}.")] 244[LoggerMessage(LogLevel.Trace, "SendAsync invoked: Message: {Message}.")] 253[LoggerMessage(LogLevel.Trace, "GetStreamingResponseAsync received server message: {ServerMessage}")]

SpeechToText\LoggingSpeechToTextClient.cs (9)

25/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 27/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment. 63if (_logger.IsEnabled(LogLevel.Trace)) 79if (_logger.IsEnabled(LogLevel.Trace)) 109if (_logger.IsEnabled(LogLevel.Trace)) 162if (_logger.IsEnabled(LogLevel.Trace)) 188[LoggerMessage(LogLevel.Trace, "{MethodName} invoked: Options: {SpeechToTextOptions}. Metadata: {SpeechToTextClientMetadata}.")] 194[LoggerMessage(LogLevel.Trace, "{MethodName} completed: {SpeechToTextResponse}.")] 200[LoggerMessage(LogLevel.Trace, "GetStreamingTextAsync received update: {SpeechToTextResponseUpdate}")]

SpeechToText\LoggingSpeechToTextClientBuilderExtensions.cs (2)

28/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 30/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment.

TextToSpeech\LoggingTextToSpeechClient.cs (5)

24/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 26/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment. 62if (_logger.IsEnabled(LogLevel.Trace)) 102if (_logger.IsEnabled(LogLevel.Trace)) 175[LoggerMessage(LogLevel.Trace, "{MethodName} invoked: Options: {TextToSpeechOptions}. Metadata: {TextToSpeechClientMetadata}.")]

TextToSpeech\LoggingTextToSpeechClientBuilderExtensions.cs (2)

28/// When the employed <see cref="ILogger"/> enables <see cref="Logging.LogLevel.Trace"/>, the contents of 30/// <see cref="Logging.LogLevel.Trace"/> is disabled by default and should never be enabled in a production environment.

ChatClientIntegrationTests.cs (4)

836using ILoggerFactory loggerFactory = LoggerFactory.Create(b => b.AddProvider(new FakeLoggerProvider(collector)).SetMinimumLevel(LogLevel.Trace)); 855using ILoggerFactory loggerFactory = LoggerFactory.Create(b => b.AddProvider(new FakeLoggerProvider(collector)).SetMinimumLevel(LogLevel.Trace)); 877using ILoggerFactory loggerFactory = LoggerFactory.Create(b => b.AddProvider(new FakeLoggerProvider(collector)).SetMinimumLevel(LogLevel.Trace)); 903using ILoggerFactory loggerFactory = LoggerFactory.Create(b => b.AddProvider(new FakeLoggerProvider(collector)).SetMinimumLevel(LogLevel.Trace));

ChatCompletion\FunctionInvokingChatClientTests.cs (2)

1035[InlineData(LogLevel.Trace)] 1070if (level is LogLevel.Trace)

ChatCompletion\LoggingChatClientTests.cs (4)

44[InlineData(LogLevel.Trace)] 73if (level is LogLevel.Trace) 92[InlineData(LogLevel.Trace)] 125if (level is LogLevel.Trace)

Embeddings\LoggingEmbeddingGeneratorTests.cs (2)

43[InlineData(LogLevel.Trace)] 70if (level is LogLevel.Trace)

Files\LoggingHostedFileClientTests.cs (10)

47[InlineData(LogLevel.Trace)] 73if (level is LogLevel.Trace) 110[InlineData(LogLevel.Trace)] 132if (level is LogLevel.Trace) 159[InlineData(LogLevel.Trace)] 181if (level is LogLevel.Trace) 217[InlineData(LogLevel.Trace)] 248if (level is LogLevel.Trace) 277[InlineData(LogLevel.Trace)] 298if (level is LogLevel.Trace)

Image\LoggingImageGeneratorTests.cs (4)

44[InlineData(LogLevel.Trace)] 73if (level is LogLevel.Trace) 95[InlineData(LogLevel.Trace)] 122if (level is LogLevel.Trace)

Realtime\LoggingRealtimeClientTests.cs (6)

63[InlineData(LogLevel.Trace)] 86if (level is LogLevel.Trace) 105[InlineData(LogLevel.Trace)] 131if (level is LogLevel.Trace) 150[InlineData(LogLevel.Trace)] 183if (level is LogLevel.Trace)

SpeechToText\LoggingSpeechToTextClientTests.cs (4)

46[InlineData(LogLevel.Trace)] 76if (level is LogLevel.Trace) 95[InlineData(LogLevel.Trace)] 129if (level is LogLevel.Trace)

TextToSpeech\LoggingTextToSpeechClientTests.cs (4)

44[InlineData(LogLevel.Trace)] 73if (level is LogLevel.Trace) 94[InlineData(LogLevel.Trace)] 127if (level is LogLevel.Trace)

Logging\FakeLogRecord.cs (1)

140LogLevel.Trace => "trace",

Logging\FakeLoggerTests.cs (2)

149Assert.True(logger.IsEnabled(LogLevel.Trace)); 160Assert.True(logger.IsEnabled(LogLevel.Trace));

Logging\LogHelper.cs (8)

76if (logger.IsEnabled(LogLevel.Trace)) 79LogLevel.Trace, 91if (logger.IsEnabled(LogLevel.Trace)) 94LogLevel.Trace, 115if (logger.IsEnabled(LogLevel.Trace)) 118LogLevel.Trace, 130if (logger.IsEnabled(LogLevel.Trace)) 133LogLevel.Trace,

Logger.cs (1)

248LogLevel.Trace,

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

41LogLevel.Trace,

LoggerExtensions.cs (4)

102logger.Log(LogLevel.Trace, eventId, exception, message, args); 119logger.Log(LogLevel.Trace, eventId, message, args); 136logger.Log(LogLevel.Trace, exception, message, args); 152logger.Log(LogLevel.Trace, message, args);

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

41LogLevel.Trace,

ConfigurationBasedLevelSwitcher.cs (1)

44return LogLevel.Trace;

JsonConsoleFormatter.cs (1)

123LogLevel.Trace => "Trace",

SimpleConsoleFormatter.cs (2)

171LogLevel.Trace => "trce", 195LogLevel.Trace => new ConsoleColors(ConsoleColor.Gray, ConsoleColor.Black),

SystemdConsoleFormatter.cs (1)

129LogLevel.Trace => "<7>",

EventLogLogger.cs (1)

191case LogLevel.Trace:

EventSourceLogger.cs (1)

54Level = LogLevel.Trace;

LoggingEventSource.cs (2)

502ret = LogLevel.Trace; 524if (!(LogLevel.Trace <= (LogLevel)level && (LogLevel)level <= LogLevel.None))

MSBuildLogger.cs (2)

53LogLevel.Trace => _loggingHelper.LogsMessagesOfImportance(MessageImportance.Low), 66case LogLevel.Trace:

TraceSourceLogger.cs (1)

76case LogLevel.Trace:

DnsServiceEndpointProviderBase.Log.cs (2)

12[LoggerMessage(1, LogLevel.Trace, "Resolving endpoints for service '{ServiceName}' using DNS SRV lookup for name '{RecordName}'.", EventName = "SrvQuery")] 15[LoggerMessage(2, LogLevel.Trace, "Resolving endpoints for service '{ServiceName}' using host lookup for name '{RecordName}'.", EventName = "AddressQuery")]

XunitLoggerFactoryExtensions.cs (1)

35: this(output, LogLevel.Trace)

Sampling\RandomProbabilisticSamplerTests.cs (2)

28options.Rules.Add(new RandomProbabilisticSamplerFilterRule(probability: probability, logLevel: LogLevel.Trace)); 34LogLevel.Trace, nameof(SamplesAsConfigured), 0, _dummyState, _dummyException, _dummyFormatter));

Sampling\TraceBasedSamplerTests.cs (3)

29LogLevel.Trace, nameof(WhenNoActivity_SamplesIn), 0, _dummyState, _dummyException, _dummyFormatter)); 48LogLevel.Trace, nameof(WhenActivityIsRecorded_SamplesIn), 0, _dummyState, _dummyException, _dummyFormatter)); 69LogLevel.Trace, nameof(WhenActivityIsNotRecorded_SamplesOut), 0, _dummyState, _dummyException, _dummyFormatter));

LogMethodTests.cs (7)

103fakeLogger.ControlLevel(LogLevel.Trace, false); 110LevelTestExtensions.M8(logger, LogLevel.Trace); 345Assert.Equal(LogLevel.Trace, logRecord.Level); 360Assert.Equal(LogLevel.Trace, collector.LatestRecord.Level); 420Assert.Equal(LogLevel.Trace, collector.LatestRecord.Level); 578Assert.Equal(LogLevel.Trace, collector.LatestRecord.Level); 616Assert.Equal(LogLevel.Trace, collector.LatestRecord.Level);

TagProviderTests.cs (6)

101TagProviderExtensions.DefaultAttributeCtor(_logger, LogLevel.Trace, classToLog); 107Assert.Equal(LogLevel.Trace, latestRecord.Level); 122TagProviderExtensions.Nullable(_logger, LogLevel.Trace, null); 128Assert.Equal(LogLevel.Trace, latestRecord.Level); 133TagProviderExtensions.Nullable(_logger, LogLevel.Trace, 42); 139Assert.Equal(LogLevel.Trace, latestRecord.Level);

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

34[LoggerMessage(Level = LogLevel.Trace, EventName = "EN1", EventId = 42, Message = "M8", SkipEnabledCheck = true)]

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

10[LoggerMessage(0, LogLevel.Trace, "M0", EventName = "CustomEventName")]

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

11[LoggerMessage(0, LogLevel.Trace, "M0 {ex2}")]

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

10[LoggerMessage(0, LogLevel.Trace, "M0")]

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

10[LoggerMessage(0, LogLevel.Trace, null!)] 21[LoggerMessage(LogLevel.Trace)]

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

10[LoggerMessage(0, LogLevel.Trace, "M0")]

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

22[LoggerMessage(1, LogLevel.Trace, "M1 {p1}")]

Utils.cs (1)

74builder.SetMinimumLevel(LogLevel.Trace);

Registry\HttpExtensions.cs (1)

69if (logger.IsEnabled(LogLevel.Trace))

CliConsoleFormatter.cs (2)

49case LogLevel.Trace: 100if (logEntry.LogLevel == LogLevel.Debug || logEntry.LogLevel == LogLevel.Trace)

Program.cs (1)

12builder.Logging.SetMinimumLevel(LogLevel.Trace);