using Microsoft.Extensions.Logging; using System.ClientModel.Internal; using System.Collections.Generic; using System.Runtime.CompilerServices; namespace System.ClientModel.Primitives { [System.Runtime.CompilerServices.NullableContext(1)] [System.Runtime.CompilerServices.Nullable(0)] public class ClientLoggingOptions { private bool _frozen; private bool? _enableLogging; private bool? _enableMessageLogging; private bool? _enableMessageContentLogging; private int? _messageContentSizeLimit; [System.Runtime.CompilerServices.Nullable(2)] private ILoggerFactory _loggerFactory; [System.Runtime.CompilerServices.Nullable(2)] private PipelineMessageSanitizer _sanitizer; [System.Runtime.CompilerServices.Nullable(2)] private ChangeTrackingStringList _allowedHeaderNames; [System.Runtime.CompilerServices.Nullable(2)] private ChangeTrackingStringList _allowedQueryParameters; private static readonly HashSet<string> s_defaultAllowedHeaderNames = new HashSet<string> { "traceparent", "Accept", "Cache-Control", "Connection", "Content-Length", "Content-Type", "Date", "ETag", "Expires", "If-Match", "If-Modified-Since", "If-None-Match", "If-Unmodified-Since", "Last-Modified", "Pragma", "Retry-After", "Server", "Transfer-Encoding", "User-Agent", "WWW-Authenticate" }; private static readonly HashSet<string> s_defaultAllowedQueryParameters = new HashSet<string> { "api-version" }; private static readonly PipelineMessageSanitizer s_defaultSanitizer = new PipelineMessageSanitizer(s_defaultAllowedQueryParameters, s_defaultAllowedHeaderNames, "REDACTED"); internal const bool DefaultEnableLogging = true; internal const bool DefaultEnableMessageContentLogging = false; internal const int DefaultMessageContentSizeLimitBytes = 4096; internal const double RequestTooLongSeconds = 3; [System.Runtime.CompilerServices.Nullable(2)] public ILoggerFactory LoggerFactory { [System.Runtime.CompilerServices.NullableContext(2)] get { return _loggerFactory; } [System.Runtime.CompilerServices.NullableContext(2)] set { AssertNotFrozen(); _loggerFactory = value; } } public bool? EnableLogging { get { return _enableLogging; } set { AssertNotFrozen(); _enableLogging = value; } } public bool? EnableMessageLogging { get { return _enableMessageLogging; } set { AssertNotFrozen(); _enableMessageLogging = value; } } public bool? EnableMessageContentLogging { get { return _enableMessageContentLogging; } set { AssertNotFrozen(); _enableMessageContentLogging = value; } } public int? MessageContentSizeLimit { get { return _messageContentSizeLimit; } set { AssertNotFrozen(); _messageContentSizeLimit = value; } } public IList<string> AllowedHeaderNames { get { if (!_frozen) { if (_allowedHeaderNames == null) { ChangeTrackingStringList changeTrackingStringList = _allowedHeaderNames = new ChangeTrackingStringList(s_defaultAllowedHeaderNames); } return _allowedHeaderNames; } if (_allowedHeaderNames == null) { _allowedHeaderNames = new ChangeTrackingStringList(s_defaultAllowedHeaderNames); _allowedHeaderNames.Freeze(); } return _allowedHeaderNames; } } public IList<string> AllowedQueryParameters { get { if (!_frozen) { if (_allowedQueryParameters == null) { ChangeTrackingStringList changeTrackingStringList = _allowedQueryParameters = new ChangeTrackingStringList(s_defaultAllowedQueryParameters); } return _allowedQueryParameters; } if (_allowedQueryParameters == null) { _allowedQueryParameters = new ChangeTrackingStringList(s_defaultAllowedQueryParameters); _allowedQueryParameters.Freeze(); } return _allowedQueryParameters; } } internal bool AddMessageLoggingPolicy => EnableMessageLogging ?? EnableLogging.GetValueOrDefault(true); internal bool UseDefaultClientWideLogging { get { if (LoggerFactory == null) return !EnableLogging.HasValue; return false; } } internal bool AddDefaultMessageLoggingPolicy { get { if (!EnableLogging.HasValue && !MessageContentSizeLimit.HasValue && !EnableMessageLogging.HasValue && !EnableMessageContentLogging.HasValue && LoggerFactory == null && HeaderListIsDefault) return QueryParameterListIsDefault; return false; } } private bool HeaderListIsDefault { get { if (_allowedHeaderNames != null) return !_allowedHeaderNames.HasChanged; return true; } } private bool QueryParameterListIsDefault { get { if (_allowedQueryParameters != null) return !_allowedQueryParameters.HasChanged; return true; } } public virtual void Freeze() { _frozen = true; if (_allowedHeaderNames != null) _allowedHeaderNames.Freeze(); if (_allowedQueryParameters != null) _allowedQueryParameters.Freeze(); } protected void AssertNotFrozen() { if (_frozen) throw new InvalidOperationException("Cannot change a ClientLoggingOptions instance after the ClientPipeline is created."); } internal void ValidateOptions() { bool? enableLogging = EnableLogging; bool flag = false; if (((enableLogging.GetValueOrDefault() == flag) & enableLogging.HasValue) && (EnableMessageLogging.GetValueOrDefault() || EnableMessageContentLogging.GetValueOrDefault())) throw new InvalidOperationException("HTTP Message logging cannot be enabled when client-wide logging is disabled."); enableLogging = EnableMessageLogging; flag = false; if (((enableLogging.GetValueOrDefault() == flag) & enableLogging.HasValue) && EnableMessageContentLogging.GetValueOrDefault()) throw new InvalidOperationException("HTTP Message content logging cannot be enabled when HTTP message logging is disabled."); } internal PipelineMessageSanitizer GetPipelineMessageSanitizer() { if (HeaderListIsDefault && QueryParameterListIsDefault) return s_defaultSanitizer; HashSet<string> allowedHeaders = (_allowedHeaderNames == null) ? s_defaultAllowedHeaderNames : new HashSet<string>(_allowedHeaderNames, StringComparer.InvariantCultureIgnoreCase); HashSet<string> allowedQueryParameters = (_allowedQueryParameters == null) ? s_defaultAllowedQueryParameters : new HashSet<string>(_allowedQueryParameters, StringComparer.InvariantCultureIgnoreCase); if (_sanitizer == null) _sanitizer = new PipelineMessageSanitizer(allowedQueryParameters, allowedHeaders, "REDACTED"); return _sanitizer; } } }