public LoggingPolicy(bool logContent, int maxLength, string[] allowedHeaderNames, string[] allowedQueryParameters, string?assemblyName)
{
_sanitizer = new HttpMessageSanitizer(allowedQueryParameters, allowedHeaderNames);
_logContent = logContent;
_maxLength = maxLength;
_assemblyName = assemblyName;
}
public LoggingPolicy(bool logContent, int maxLength, HttpMessageSanitizer sanitizer, string?assemblyName)
{
_sanitizer = sanitizer;
_logContent = logContent;
_maxLength = maxLength;
_assemblyName = assemblyName;
}
public ClientDiagnostics(ClientOptions options) : base(
options.GetType().Namespace,
GetResourceProviderNamespace(options.GetType().Assembly),
options.Diagnostics.IsDistributedTracingEnabled)
{
_sanitizer = new HttpMessageSanitizer(
options.Diagnostics.LoggedQueryParameters.ToArray(),
options.Diagnostics.LoggedHeaderNames.ToArray());
}
public void ApiVersionIsNotSanitizedByDefault()
{
HttpMessageSanitizer sanitizer = ClientDiagnostics.CreateMessageSanitizer(ClientOptions.Default.Diagnostics);
var uriBuilder = new RequestUriBuilder();
uriBuilder.Reset(new Uri("http://localhost/"));
uriBuilder.AppendQuery("api-version", "2021-11-01");
Assert.AreEqual("http://localhost/?api-version=2021-11-01", sanitizer.SanitizeUrl(uriBuilder.ToString()));
}
public void QueryIsSanitizedAppendQuery()
{
var sanitizer = new HttpMessageSanitizer(Array.Empty <string>(), Array.Empty <string>(), "*");
var uriBuilder = new RequestUriBuilder();
uriBuilder.Reset(new Uri("http://localhost/"));
uriBuilder.AppendQuery("a", "b");
Assert.AreEqual("http://localhost/?a=*", sanitizer.SanitizeUrl(uriBuilder.ToString()));
}
public void QueryIsSanitized(string input, string expected)
{
var sanitizer = new HttpMessageSanitizer(new[]
{
"A",
"a1",
"a-2"
}, Array.Empty <string>(), "*");
Assert.AreEqual("http://localhost/" + expected, sanitizer.SanitizeUrl("http://localhost/" + input));
}
public void CanRemoveApiVersionFromLoggedQueryParams()
{
var options = new DefaultClientOptions();
options.Diagnostics.LoggedQueryParameters.Remove("api-version");
HttpMessageSanitizer sanitizer = ClientDiagnostics.CreateMessageSanitizer(options.Diagnostics);
var uriBuilder = new RequestUriBuilder();
uriBuilder.Reset(new Uri("http://localhost/"));
uriBuilder.AppendQuery("api-version", "2021-11-01");
Assert.AreEqual("http://localhost/?api-version=REDACTED", sanitizer.SanitizeUrl(uriBuilder.ToString()));
}
internal static (ResponseClassifier Classifier, HttpPipelineTransport Transport, int PerCallIndex, int PerRetryIndex, HttpPipelinePolicy[] Policies, bool IsTransportOwned) BuildInternal(
ClientOptions options,
HttpPipelinePolicy[] perCallPolicies,
HttpPipelinePolicy[] perRetryPolicies,
HttpPipelineTransportOptions?defaultTransportOptions,
ResponseClassifier?responseClassifier)
{
if (perCallPolicies == null)
{
throw new ArgumentNullException(nameof(perCallPolicies));
}
if (perRetryPolicies == null)
{
throw new ArgumentNullException(nameof(perRetryPolicies));
}
var policies = new List <HttpPipelinePolicy>(8 +
(options.Policies?.Count ?? 0) +
perCallPolicies.Length +
perRetryPolicies.Length);
void AddCustomerPolicies(HttpPipelinePosition position)
{
if (options.Policies != null)
{
foreach (var policy in options.Policies)
{
if (policy.Position == position)
{
policies.Add(policy.Policy);
}
}
}
}
DiagnosticsOptions diagnostics = options.Diagnostics;
var sanitizer = new HttpMessageSanitizer(diagnostics.LoggedQueryParameters.ToArray(), diagnostics.LoggedHeaderNames.ToArray());
bool isDistributedTracingEnabled = options.Diagnostics.IsDistributedTracingEnabled;
policies.Add(ReadClientRequestIdPolicy.Shared);
policies.AddRange(perCallPolicies);
AddCustomerPolicies(HttpPipelinePosition.PerCall);
policies.RemoveAll(static policy => policy == null);
internal static (ResponseClassifier Classifier, HttpPipelineTransport Transport, int PerCallIndex, int PerRetryIndex, HttpPipelinePolicy[] Policies, bool IsTransportOwned) BuildInternal(
ClientOptions options,
HttpPipelinePolicy[] perCallPolicies,
HttpPipelinePolicy[] perRetryPolicies,
HttpPipelineTransportOptions?defaultTransportOptions,
ResponseClassifier?responseClassifier)
{
if (perCallPolicies == null)
{
throw new ArgumentNullException(nameof(perCallPolicies));
}
if (perRetryPolicies == null)
{
throw new ArgumentNullException(nameof(perRetryPolicies));
}
var policies = new List <HttpPipelinePolicy>(8 +
(options.Policies?.Count ?? 0) +
perCallPolicies.Length +
perRetryPolicies.Length);
void AddCustomerPolicies(HttpPipelinePosition position)
{
if (options.Policies != null)
{
foreach (var policy in options.Policies)
{
// skip null policies to ensure that calculations for perCallIndex and perRetryIndex are accurate
if (policy.Position == position && policy.Policy != null)
{
policies.Add(policy.Policy);
}
}
}
}
// A helper to ensure that we only add non-null policies to the policies list
// This ensures that calculations for perCallIndex and perRetryIndex are accurate
void AddNonNullPolicies(HttpPipelinePolicy[] policiesToAdd)
{
for (int i = 0; i < policiesToAdd.Length; i++)
{
var policy = policiesToAdd[i];
if (policy != null)
{
policies.Add(policy);
}
}
}
DiagnosticsOptions diagnostics = options.Diagnostics;
var sanitizer = new HttpMessageSanitizer(diagnostics.LoggedQueryParameters.ToArray(), diagnostics.LoggedHeaderNames.ToArray());
bool isDistributedTracingEnabled = options.Diagnostics.IsDistributedTracingEnabled;
policies.Add(ReadClientRequestIdPolicy.Shared);
AddNonNullPolicies(perCallPolicies);
AddCustomerPolicies(HttpPipelinePosition.PerCall);
var perCallIndex = policies.Count;
policies.Add(ClientRequestIdPolicy.Shared);
if (diagnostics.IsTelemetryEnabled)
{
policies.Add(CreateTelemetryPolicy(options));
}
RetryOptions retryOptions = options.Retry;
policies.Add(new RetryPolicy(retryOptions.Mode, retryOptions.Delay, retryOptions.MaxDelay, retryOptions.MaxRetries));
policies.Add(RedirectPolicy.Shared);
AddNonNullPolicies(perRetryPolicies);
AddCustomerPolicies(HttpPipelinePosition.PerRetry);
var perRetryIndex = policies.Count;
if (diagnostics.IsLoggingEnabled)
{
string assemblyName = options.GetType().Assembly !.GetName().Name !;
policies.Add(new LoggingPolicy(diagnostics.IsLoggingContentEnabled, diagnostics.LoggedContentSizeLimit, sanitizer, assemblyName));
}
policies.Add(new ResponseBodyPolicy(options.Retry.NetworkTimeout));
policies.Add(new RequestActivityPolicy(isDistributedTracingEnabled, ClientDiagnostics.GetResourceProviderNamespace(options.GetType().Assembly), sanitizer));
AddCustomerPolicies(HttpPipelinePosition.BeforeTransport);
// Override the provided Transport with the provided transport options if the transport has not been set after default construction and options are not null.
HttpPipelineTransport transport = options.Transport;
bool isTransportInternallyCreated = false;
if (defaultTransportOptions != null)
{
if (options.IsCustomTransportSet)
{
if (AzureCoreEventSource.Singleton.IsEnabled())
{
// Log that we were unable to override the custom transport
AzureCoreEventSource.Singleton.PipelineTransportOptionsNotApplied(options?.GetType().FullName ?? String.Empty);
}
}
else
{
transport = HttpPipelineTransport.Create(defaultTransportOptions);
isTransportInternallyCreated = true;
}
}
policies.Add(new HttpPipelineTransportPolicy(transport, sanitizer));
responseClassifier ??= ResponseClassifier.Shared;
return(responseClassifier, transport, perCallIndex, perRetryIndex, policies.ToArray(), isTransportInternallyCreated);
}
public RequestActivityPolicy(bool isDistributedTracingEnabled, string?resourceProviderNamespace, HttpMessageSanitizer httpMessageSanitizer)
{
_isDistributedTracingEnabled = isDistributedTracingEnabled;
_resourceProviderNamespace = resourceProviderNamespace;
_sanitizer = httpMessageSanitizer;
}
public HttpPipelineTransportPolicy(HttpPipelineTransport transport, HttpMessageSanitizer sanitizer)
{
_transport = transport;
_sanitizer = sanitizer;
}
public MockPolicy(HttpPipelineTransport transport, HttpMessageSanitizer sanitizer) : base(transport, sanitizer)
{
}
/// <summary>
/// Creates an instance of <see cref="HttpPipeline"/> populated with default policies, customer provided policies from <paramref name="options"/> and client provided per call policies.
/// </summary>
/// <param name="options">The customer provided client options object.</param>
/// <param name="perCallPolicies">Client provided per-call policies.</param>
/// <param name="perRetryPolicies">Client provided per-retry policies.</param>
/// <param name="responseClassifier">The client provided response classifier.</param>
/// <returns>A new instance of <see cref="HttpPipeline"/></returns>
public static HttpPipeline Build(ClientOptions options, HttpPipelinePolicy[] perCallPolicies, HttpPipelinePolicy[] perRetryPolicies, ResponseClassifier responseClassifier)
{
if (perCallPolicies == null)
{
throw new ArgumentNullException(nameof(perCallPolicies));
}
if (perRetryPolicies == null)
{
throw new ArgumentNullException(nameof(perRetryPolicies));
}
var policies = new List <HttpPipelinePolicy>(8 +
(options.Policies?.Count ?? 0) +
perCallPolicies.Length +
perRetryPolicies.Length);
void AddCustomerPolicies(HttpPipelinePosition position)
{
if (options.Policies != null)
{
foreach (var policy in options.Policies)
{
if (policy.Position == position)
{
policies.Add(policy.Policy);
}
}
}
}
DiagnosticsOptions diagnostics = options.Diagnostics;
var sanitizer = new HttpMessageSanitizer(diagnostics.LoggedHeaderNames.ToArray(), diagnostics.LoggedQueryParameters.ToArray());
bool isDistributedTracingEnabled = options.Diagnostics.IsDistributedTracingEnabled;
policies.Add(ReadClientRequestIdPolicy.Shared);
policies.AddRange(perCallPolicies);
AddCustomerPolicies(HttpPipelinePosition.PerCall);
policies.Add(ClientRequestIdPolicy.Shared);
if (diagnostics.IsTelemetryEnabled)
{
policies.Add(CreateTelemetryPolicy(options));
}
RetryOptions retryOptions = options.Retry;
policies.Add(new RetryPolicy(retryOptions.Mode, retryOptions.Delay, retryOptions.MaxDelay, retryOptions.MaxRetries));
policies.Add(RedirectPolicy.Shared);
policies.AddRange(perRetryPolicies);
AddCustomerPolicies(HttpPipelinePosition.PerRetry);
if (diagnostics.IsLoggingEnabled)
{
string assemblyName = options.GetType().Assembly !.GetName().Name !;
policies.Add(new LoggingPolicy(diagnostics.IsLoggingContentEnabled, diagnostics.LoggedContentSizeLimit, sanitizer, assemblyName));
}
policies.Add(new ResponseBodyPolicy(options.Retry.NetworkTimeout));
policies.Add(new RequestActivityPolicy(isDistributedTracingEnabled, ClientDiagnostics.GetResourceProviderNamespace(options.GetType().Assembly), sanitizer));
AddCustomerPolicies(HttpPipelinePosition.BeforeTransport);
policies.RemoveAll(static policy => policy == null);
/// <summary>
/// </summary>
public ExceptionFormattingResponseClassifier(ResponseClassifier responseClassifier, DiagnosticsOptions diagnostics)
{
_responseClassifier = responseClassifier;
MessageSanitizer = ClientDiagnostics.CreateMessageSanitizer(diagnostics);
}
