private async Task <ContainerProperties> ReadCollectionAsync(
string collectionLink,
IDocumentClientRetryPolicy retryPolicyInstance,
ITrace trace,
IClientSideRequestStatistics clientSideRequestStatistics,
CancellationToken cancellationToken)
{
using (ITrace childTrace = trace.StartChild("Read Collection", TraceComponent.Transport, TraceLevel.Info))
{
cancellationToken.ThrowIfCancellationRequested();
RequestNameValueCollection headers = new RequestNameValueCollection();
using (DocumentServiceRequest request = DocumentServiceRequest.Create(
OperationType.Read,
ResourceType.Collection,
collectionLink,
AuthorizationTokenType.PrimaryMasterKey,
headers))
{
headers.XDate = Rfc1123DateTimeCache.UtcNow();
request.RequestContext.ClientRequestStatistics = clientSideRequestStatistics ?? new ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow, trace.Summary);
if (clientSideRequestStatistics == null)
{
childTrace.AddDatum(
"Client Side Request Stats",
request.RequestContext.ClientRequestStatistics);
}
string authorizationToken = await this.tokenProvider.GetUserAuthorizationTokenAsync(
request.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
HttpConstants.HttpMethods.Get,
request.Headers,
AuthorizationTokenType.PrimaryMasterKey,
childTrace);
headers.Authorization = authorizationToken;
using (new ActivityScope(Guid.NewGuid()))
{
retryPolicyInstance?.OnBeforeSendRequest(request);
try
{
using (DocumentServiceResponse response =
await this.storeModel.ProcessMessageAsync(request))
{
return(CosmosResource.FromStream <ContainerProperties>(response));
}
}
catch (DocumentClientException ex)
{
childTrace.AddDatum("Exception Message", ex.Message);
throw;
}
}
}
}
}
internal Task <DocumentServiceResponse> ProcessMessageAsync(
CosmosRequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
DocumentServiceRequest serviceRequest = request.ToDocumentServiceRequest();
//TODO: extrace auth into a separate handler
string authorization = ((IAuthorizationTokenProvider)this.client.DocumentClient).GetUserAuthorizationToken(
serviceRequest.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
request.Method.ToString(), serviceRequest.Headers, AuthorizationTokenType.PrimaryMasterKey);
serviceRequest.Headers[HttpConstants.HttpHeaders.Authorization] = authorization;
IStoreModel storeProxy = this.client.DocumentClient.GetStoreProxy(serviceRequest);
if (request.OperationType == OperationType.Upsert)
{
return(this.ProcessUpsertAsync(storeProxy, serviceRequest, cancellationToken));
}
else
{
return(storeProxy.ProcessMessageAsync(serviceRequest, cancellationToken));
}
}
private async Task <DocumentServiceResponse> ExecutePartitionKeyRangeReadChangeFeedAsync(string collectionRid,
INameValueCollection headers,
ITrace trace)
{
using (ITrace childTrace = trace.StartChild("Read PartitionKeyRange Change Feed", TraceComponent.Transport, Tracing.TraceLevel.Info))
{
using (DocumentServiceRequest request = DocumentServiceRequest.Create(
OperationType.ReadFeed,
collectionRid,
ResourceType.PartitionKeyRange,
AuthorizationTokenType.PrimaryMasterKey,
headers))
{
string authorizationToken = null;
try
{
authorizationToken = (await this.authorizationTokenProvider.GetUserAuthorizationAsync(
request.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
HttpConstants.HttpMethods.Get,
request.Headers,
AuthorizationTokenType.PrimaryMasterKey)).token;
}
catch (UnauthorizedException)
{
}
if (authorizationToken == null)
{
// User doesn't have rid based resource token. Maybe he has name based.
throw new NotSupportedException("Resource tokens are not supported");
////CosmosContainerSettings collection = await this.collectionCache.ResolveCollectionAsync(request, CancellationToken.None);
////authorizationToken =
//// this.authorizationTokenProvider.GetUserAuthorizationTokenAsync(
//// collection.AltLink,
//// PathsHelper.GetResourcePath(request.ResourceType),
//// HttpConstants.HttpMethods.Get,
//// request.Headers,
//// AuthorizationTokenType.PrimaryMasterKey);
}
request.Headers[HttpConstants.HttpHeaders.Authorization] = authorizationToken;
using (new ActivityScope(Guid.NewGuid()))
{
try
{
return(await this.storeModel.ProcessMessageAsync(request));
}
catch (DocumentClientException ex)
{
childTrace.AddDatum("Exception Message", ex.Message);
throw;
}
}
}
}
}
private async Task <FeedResource <Address> > GetMasterAddressesViaGatewayAsync(
DocumentServiceRequest request,
ResourceType resourceType,
string resourceAddress,
string entryUrl,
bool forceRefresh,
bool useMasterCollectionResolver)
{
INameValueCollection addressQuery = new DictionaryNameValueCollection(StringComparer.Ordinal);
addressQuery.Add(HttpConstants.QueryStrings.Url, HttpUtility.UrlEncode(entryUrl));
INameValueCollection headers = new DictionaryNameValueCollection(StringComparer.Ordinal);
if (forceRefresh)
{
headers.Set(HttpConstants.HttpHeaders.ForceRefresh, bool.TrueString);
}
if (useMasterCollectionResolver)
{
headers.Set(HttpConstants.HttpHeaders.UseMasterCollectionResolver, bool.TrueString);
}
if (request.ForceCollectionRoutingMapRefresh)
{
headers.Set(HttpConstants.HttpHeaders.ForceCollectionRoutingMapRefresh, bool.TrueString);
}
addressQuery.Add(HttpConstants.QueryStrings.Filter, this.protocolFilter);
string resourceTypeToSign = PathsHelper.GetResourcePath(resourceType);
headers.Set(HttpConstants.HttpHeaders.XDate, DateTime.UtcNow.ToString("r", CultureInfo.InvariantCulture));
string token = this.tokenProvider.GetUserAuthorizationToken(
resourceAddress,
resourceTypeToSign,
HttpConstants.HttpMethods.Get,
headers,
AuthorizationTokenType.PrimaryMasterKey,
payload: out _);
headers.Set(HttpConstants.HttpHeaders.Authorization, token);
Uri targetEndpoint = UrlUtility.SetQuery(this.addressEndpoint, UrlUtility.CreateQuery(addressQuery));
string identifier = GatewayAddressCache.LogAddressResolutionStart(request, targetEndpoint);
using (HttpResponseMessage httpResponseMessage = await this.httpClient.GetAsync(targetEndpoint, headers))
{
using (DocumentServiceResponse documentServiceResponse =
await ClientExtensions.ParseResponseAsync(httpResponseMessage))
{
GatewayAddressCache.LogAddressResolutionEnd(request, identifier);
return(documentServiceResponse.GetResource <FeedResource <Address> >());
}
}
}
private async Task <DocumentServiceResponse> GetMasterAddressesViaGatewayAsync(
DocumentServiceRequest request,
ResourceType resourceType,
string resourceAddress,
string entryUrl,
bool forceRefresh,
bool useMasterCollectionResolver)
{
INameValueCollection addressQuery = new RequestNameValueCollection
{
{ HttpConstants.QueryStrings.Url, HttpUtility.UrlEncode(entryUrl) }
};
INameValueCollection headers = new RequestNameValueCollection();
if (forceRefresh)
{
headers.Set(HttpConstants.HttpHeaders.ForceRefresh, bool.TrueString);
}
if (useMasterCollectionResolver)
{
headers.Set(HttpConstants.HttpHeaders.UseMasterCollectionResolver, bool.TrueString);
}
if (request.ForceCollectionRoutingMapRefresh)
{
headers.Set(HttpConstants.HttpHeaders.ForceCollectionRoutingMapRefresh, bool.TrueString);
}
addressQuery.Add(HttpConstants.QueryStrings.Filter, this.protocolFilter);
string resourceTypeToSign = PathsHelper.GetResourcePath(resourceType);
headers.Set(HttpConstants.HttpHeaders.XDate, Rfc1123DateTimeCache.UtcNow());
using (ITrace trace = Trace.GetRootTrace(nameof(GetMasterAddressesViaGatewayAsync), TraceComponent.Authorization, TraceLevel.Info))
{
string token = await this.tokenProvider.GetUserAuthorizationTokenAsync(
resourceAddress,
resourceTypeToSign,
HttpConstants.HttpMethods.Get,
headers,
AuthorizationTokenType.PrimaryMasterKey,
trace);
headers.Set(HttpConstants.HttpHeaders.Authorization, token);
Uri targetEndpoint = UrlUtility.SetQuery(this.addressEndpoint, UrlUtility.CreateQuery(addressQuery));
string identifier = GatewayAddressCache.LogAddressResolutionStart(request, targetEndpoint);
using (HttpResponseMessage httpResponseMessage = await this.httpClient.GetAsync(
uri: targetEndpoint,
additionalHeaders: headers,
resourceType: resourceType,
timeoutPolicy: HttpTimeoutPolicyControlPlaneRetriableHotPath.Instance,
clientSideRequestStatistics: request.RequestContext?.ClientRequestStatistics,
cancellationToken: default))
private async Task <FeedResource <Address> > GetMasterAddressesViaGatewayAsync(
DocumentServiceRequest request,
ResourceType resourceType,
string resourceAddress,
string entryUrl,
bool forceRefresh,
bool useMasterCollectionResolver)
{
INameValueCollection addressQuery = new StoreRequestNameValueCollection
{
{ HttpConstants.QueryStrings.Url, HttpUtility.UrlEncode(entryUrl) }
};
INameValueCollection headers = new StoreRequestNameValueCollection();
if (forceRefresh)
{
headers.Set(HttpConstants.HttpHeaders.ForceRefresh, bool.TrueString);
}
if (useMasterCollectionResolver)
{
headers.Set(HttpConstants.HttpHeaders.UseMasterCollectionResolver, bool.TrueString);
}
if (request.ForceCollectionRoutingMapRefresh)
{
headers.Set(HttpConstants.HttpHeaders.ForceCollectionRoutingMapRefresh, bool.TrueString);
}
addressQuery.Add(HttpConstants.QueryStrings.Filter, this.protocolFilter);
string resourceTypeToSign = PathsHelper.GetResourcePath(resourceType);
headers.Set(HttpConstants.HttpHeaders.XDate, DateTime.UtcNow.ToString("r", CultureInfo.InvariantCulture));
(string token, string _) = await this.tokenProvider.GetUserAuthorizationAsync(
resourceAddress,
resourceTypeToSign,
HttpConstants.HttpMethods.Get,
headers,
AuthorizationTokenType.PrimaryMasterKey);
headers.Set(HttpConstants.HttpHeaders.Authorization, token);
Uri targetEndpoint = UrlUtility.SetQuery(this.addressEndpoint, UrlUtility.CreateQuery(addressQuery));
string identifier = GatewayAddressCache.LogAddressResolutionStart(request, targetEndpoint);
using (HttpResponseMessage httpResponseMessage = await this.httpClient.GetAsync(
uri: targetEndpoint,
additionalHeaders: headers,
resourceType: resourceType,
timeoutPolicy: HttpTimeoutPolicyControlPlaneHotPath.Instance,
diagnosticsContext: null,
cancellationToken: default))
internal async Task <ResponseMessage> ProcessMessageAsync(
RequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
DocumentServiceRequest serviceRequest = request.ToDocumentServiceRequest();
ClientSideRequestStatisticsTraceDatum clientSideRequestStatisticsTraceDatum = new ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow);
serviceRequest.RequestContext.ClientRequestStatistics = clientSideRequestStatisticsTraceDatum;
//TODO: extrace auth into a separate handler
string authorization = await((ICosmosAuthorizationTokenProvider)this.client.DocumentClient).GetUserAuthorizationTokenAsync(
serviceRequest.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
request.Method.ToString(),
serviceRequest.Headers,
AuthorizationTokenType.PrimaryMasterKey,
request.Trace);
serviceRequest.Headers[HttpConstants.HttpHeaders.Authorization] = authorization;
IStoreModel storeProxy = this.client.DocumentClient.GetStoreProxy(serviceRequest);
using (ITrace processMessageAsyncTrace = request.Trace.StartChild(
name: $"{storeProxy.GetType().FullName} Transport Request",
component: TraceComponent.Transport,
level: Tracing.TraceLevel.Info))
{
request.Trace = processMessageAsyncTrace;
processMessageAsyncTrace.AddDatum("Client Side Request Stats", clientSideRequestStatisticsTraceDatum);
DocumentServiceResponse response = null;
try
{
response = request.OperationType == OperationType.Upsert
? await this.ProcessUpsertAsync(storeProxy, serviceRequest, cancellationToken)
: await storeProxy.ProcessMessageAsync(serviceRequest, cancellationToken);
}
finally
{
processMessageAsyncTrace.UpdateRegionContacted(clientSideRequestStatisticsTraceDatum);
}
return(response.ToCosmosResponseMessage(
request,
serviceRequest.RequestContext.RequestChargeTracker));
}
}
private async Task <ContainerProperties> ReadCollectionAsync(string collectionLink,
CancellationToken cancellationToken,
IDocumentClientRetryPolicy retryPolicyInstance,
ITrace trace)
{
using (ITrace childTrace = trace.StartChild("Read Collection", TraceComponent.Transport, TraceLevel.Info))
{
cancellationToken.ThrowIfCancellationRequested();
using (DocumentServiceRequest request = DocumentServiceRequest.Create(
OperationType.Read,
ResourceType.Collection,
collectionLink,
AuthorizationTokenType.PrimaryMasterKey,
new StoreRequestNameValueCollection()))
{
request.Headers[HttpConstants.HttpHeaders.XDate] = DateTime.UtcNow.ToString("r");
(string authorizationToken, string payload) = await this.tokenProvider.GetUserAuthorizationAsync(
request.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
HttpConstants.HttpMethods.Get,
request.Headers,
AuthorizationTokenType.PrimaryMasterKey);
request.Headers[HttpConstants.HttpHeaders.Authorization] = authorizationToken;
using (new ActivityScope(Guid.NewGuid()))
{
if (retryPolicyInstance != null)
{
retryPolicyInstance.OnBeforeSendRequest(request);
}
try
{
using (DocumentServiceResponse response = await this.storeModel.ProcessMessageAsync(request))
{
return(CosmosResource.FromStream <ContainerProperties>(response));
}
}
catch (DocumentClientException ex)
{
childTrace.AddDatum("Exception Message", ex.Message);
throw;
}
}
}
}
}
public async Task AddSystemAuthorizationHeaderAsync(
DocumentServiceRequest request,
string federationId,
string verb,
string resourceId)
{
request.Headers[HttpConstants.HttpHeaders.XDate] = DateTime.UtcNow.ToString("r", CultureInfo.InvariantCulture);
request.Headers[HttpConstants.HttpHeaders.Authorization] = (await this.GetUserAuthorizationAsync(
resourceId ?? request.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
verb,
request.Headers,
request.RequestAuthorizationTokenType)).token;
}
private async Task <DocumentServiceResponse> ExecutePartitionKeyRangeReadChangeFeed(string collectionRid, INameValueCollection headers)
{
using (DocumentServiceRequest request = DocumentServiceRequest.Create(
OperationType.ReadFeed,
collectionRid,
ResourceType.PartitionKeyRange,
AuthorizationTokenType.PrimaryMasterKey,
headers))
{
string authorizationToken = null;
try
{
authorizationToken =
this.authorizationTokenProvider.GetUserAuthorizationToken(
request.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
HttpConstants.HttpMethods.Get,
request.Headers,
AuthorizationTokenType.PrimaryMasterKey);
}
catch (UnauthorizedException)
{
}
if (authorizationToken == null)
{
// User doesn't have rid based resource token. Maybe he has name based.
CosmosContainerSettings collection = await this.collectionCache.ResolveCollectionAsync(request, CancellationToken.None);
authorizationToken =
this.authorizationTokenProvider.GetUserAuthorizationToken(
collection.AltLink,
PathsHelper.GetResourcePath(request.ResourceType),
HttpConstants.HttpMethods.Get,
request.Headers,
AuthorizationTokenType.PrimaryMasterKey);
}
request.Headers[HttpConstants.HttpHeaders.Authorization] = authorizationToken;
using (new ActivityScope(Guid.NewGuid()))
{
return(await this.storeModel.ProcessMessageAsync(request));
}
}
}
internal async Task <ResponseMessage> ProcessMessageAsync(
RequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
DocumentServiceRequest serviceRequest = request.ToDocumentServiceRequest();
//TODO: extrace auth into a separate handler
string authorization = await((ICosmosAuthorizationTokenProvider)this.client.DocumentClient).GetUserAuthorizationTokenAsync(
serviceRequest.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
request.Method.ToString(),
serviceRequest.Headers,
AuthorizationTokenType.PrimaryMasterKey,
request.DiagnosticsContext);
serviceRequest.Headers[HttpConstants.HttpHeaders.Authorization] = authorization;
IStoreModel storeProxy = this.client.DocumentClient.GetStoreProxy(serviceRequest);
using (ITrace processMessageAsyncTrace = request.Trace.StartChild(
name: $"{storeProxy.GetType().FullName} Transport Request",
TraceComponent.Transport,
Tracing.TraceLevel.Info))
{
using (request.DiagnosticsContext.CreateScope(storeProxy.GetType().FullName))
{
DocumentServiceResponse response = request.OperationType == OperationType.Upsert
? await this.ProcessUpsertAsync(storeProxy, serviceRequest, cancellationToken)
: await storeProxy.ProcessMessageAsync(serviceRequest, cancellationToken);
return(response.ToCosmosResponseMessage(
request,
serviceRequest.RequestContext.RequestChargeTracker,
processMessageAsyncTrace));
}
}
}
private async Task <ContainerProperties> ReadCollectionAsync(string collectionLink, CancellationToken cancellationToken, IDocumentClientRetryPolicy retryPolicyInstance)
{
cancellationToken.ThrowIfCancellationRequested();
using (DocumentServiceRequest request = DocumentServiceRequest.Create(
OperationType.Read,
ResourceType.Collection,
collectionLink,
AuthorizationTokenType.PrimaryMasterKey,
new DictionaryNameValueCollection()))
{
request.Headers[HttpConstants.HttpHeaders.XDate] = DateTime.UtcNow.ToString("r");
string payload;
string authorizationToken = this.tokenProvider.GetUserAuthorizationToken(
request.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
HttpConstants.HttpMethods.Get,
request.Headers,
AuthorizationTokenType.PrimaryMasterKey,
out payload);
request.Headers[HttpConstants.HttpHeaders.Authorization] = authorizationToken;
using (new ActivityScope(Guid.NewGuid()))
{
if (retryPolicyInstance != null)
{
retryPolicyInstance.OnBeforeSendRequest(request);
}
using (DocumentServiceResponse response = await this.storeModel.ProcessMessageAsync(request))
{
return(CosmosResource.FromStream <ContainerProperties>(response));
}
}
}
}
private async Task <DocumentServiceResponse> ExecutePartitionKeyRangeReadChangeFeed(string collectionRid, INameValueCollection headers)
{
using (DocumentServiceRequest request = DocumentServiceRequest.Create(
OperationType.ReadFeed,
collectionRid,
ResourceType.PartitionKeyRange,
AuthorizationTokenType.PrimaryMasterKey,
headers))
{
string authorizationToken = this.authorizationTokenProvider.GetUserAuthorizationToken(
request.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
HttpConstants.HttpMethods.Get,
request.Headers,
AuthorizationTokenType.PrimaryMasterKey);
request.Headers[HttpConstants.HttpHeaders.Authorization] = authorizationToken;
using (new ActivityScope(Guid.NewGuid()))
{
return(await this.storeModel.ProcessMessageAsync(request));
}
}
}
private async Task <FeedResource <Address> > GetServerAddressesViaGatewayAsync(
DocumentServiceRequest request,
string collectionRid,
IEnumerable <string> partitionKeyRangeIds,
bool forceRefresh)
{
string entryUrl = PathsHelper.GeneratePath(ResourceType.Document, collectionRid, true);
INameValueCollection addressQuery = new DictionaryNameValueCollection();
addressQuery.Add(HttpConstants.QueryStrings.Url, HttpUtility.UrlEncode(entryUrl));
INameValueCollection headers = new DictionaryNameValueCollection();
if (forceRefresh)
{
headers.Set(HttpConstants.HttpHeaders.ForceRefresh, bool.TrueString);
}
if (request.ForceCollectionRoutingMapRefresh)
{
headers.Set(HttpConstants.HttpHeaders.ForceCollectionRoutingMapRefresh, bool.TrueString);
}
addressQuery.Add(HttpConstants.QueryStrings.Filter, this.protocolFilter);
addressQuery.Add(HttpConstants.QueryStrings.PartitionKeyRangeIds, string.Join(",", partitionKeyRangeIds));
string resourceTypeToSign = PathsHelper.GetResourcePath(ResourceType.Document);
headers.Set(HttpConstants.HttpHeaders.XDate, DateTime.UtcNow.ToString("r", CultureInfo.InvariantCulture));
string token = null;
try
{
token = this.tokenProvider.GetUserAuthorizationToken(
collectionRid,
resourceTypeToSign,
HttpConstants.HttpMethods.Get,
headers,
AuthorizationTokenType.PrimaryMasterKey);
}
catch (UnauthorizedException)
{
}
if (token == null && request.IsNameBased)
{
// User doesn't have rid based resource token. Maybe he has name based.
string collectionAltLink = PathsHelper.GetCollectionPath(request.ResourceAddress);
token = this.tokenProvider.GetUserAuthorizationToken(
collectionAltLink,
resourceTypeToSign,
HttpConstants.HttpMethods.Get,
headers,
AuthorizationTokenType.PrimaryMasterKey);
}
headers.Set(HttpConstants.HttpHeaders.Authorization, token);
Uri targetEndpoint = UrlUtility.SetQuery(this.addressEndpoint, UrlUtility.CreateQuery(addressQuery));
string identifier = GatewayAddressCache.LogAddressResolutionStart(request, targetEndpoint);
using (HttpResponseMessage httpResponseMessage = await this.httpClient.GetAsync(targetEndpoint, headers))
{
using (DocumentServiceResponse documentServiceResponse =
await ClientExtensions.ParseResponseAsync(httpResponseMessage))
{
GatewayAddressCache.LogAddressResolutionEnd(request, identifier);
return(documentServiceResponse.GetResource <FeedResource <Address> >());
}
}
}
internal async Task <ResponseMessage> ProcessMessageAsync(
RequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
DocumentServiceRequest serviceRequest = request.ToDocumentServiceRequest();
ClientSideRequestStatisticsTraceDatum clientSideRequestStatisticsTraceDatum = new ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow, request.Trace.Summary);
serviceRequest.RequestContext.ClientRequestStatistics = clientSideRequestStatisticsTraceDatum;
//TODO: extrace auth into a separate handler
string authorization = await((ICosmosAuthorizationTokenProvider)this.client.DocumentClient).GetUserAuthorizationTokenAsync(
serviceRequest.ResourceAddress,
PathsHelper.GetResourcePath(request.ResourceType),
request.Method.ToString(),
serviceRequest.Headers,
AuthorizationTokenType.PrimaryMasterKey,
request.Trace);
serviceRequest.Headers[HttpConstants.HttpHeaders.Authorization] = authorization;
IStoreModel storeProxy = this.client.DocumentClient.GetStoreProxy(serviceRequest);
using (ITrace processMessageAsyncTrace = request.Trace.StartChild(
name: $"{storeProxy.GetType().FullName} Transport Request",
component: TraceComponent.Transport,
level: Tracing.TraceLevel.Info))
{
request.Trace = processMessageAsyncTrace;
processMessageAsyncTrace.AddDatum("Client Side Request Stats", clientSideRequestStatisticsTraceDatum);
DocumentServiceResponse response = null;
try
{
response = await storeProxy.ProcessMessageAsync(serviceRequest, cancellationToken);
}
catch (DocumentClientException dce)
{
// Enrich diagnostics context in-case of auth failures
if (dce.StatusCode == System.Net.HttpStatusCode.Unauthorized || dce.StatusCode == System.Net.HttpStatusCode.Forbidden)
{
TimeSpan authProvideLifeSpan = this.client.DocumentClient.cosmosAuthorization.GetAge();
processMessageAsyncTrace.AddDatum("AuthProvider LifeSpan InSec", authProvideLifeSpan.TotalSeconds);
}
throw;
}
finally
{
processMessageAsyncTrace.UpdateRegionContacted(clientSideRequestStatisticsTraceDatum);
}
ResponseMessage responseMessage = response.ToCosmosResponseMessage(
request,
serviceRequest.RequestContext.RequestChargeTracker);
// Enrich diagnostics context in-case of auth failures
if (responseMessage?.StatusCode == System.Net.HttpStatusCode.Unauthorized || responseMessage?.StatusCode == System.Net.HttpStatusCode.Forbidden)
{
TimeSpan authProvideLifeSpan = this.client.DocumentClient.cosmosAuthorization.GetAge();
processMessageAsyncTrace.AddDatum("AuthProvider LifeSpan InSec", authProvideLifeSpan.TotalSeconds);
}
return(responseMessage);
}
}