internal static ResponseMessage ToCosmosResponseMessage(this DocumentClientException documentClientException, RequestMessage requestMessage)
{
CosmosDiagnosticsContext diagnosticsContext = requestMessage?.DiagnosticsContext;
if (requestMessage != null)
{
diagnosticsContext = requestMessage.DiagnosticsContext;
if (diagnosticsContext == null)
{
throw new ArgumentNullException("Request message should contain a DiagnosticsContext");
}
}
else
{
diagnosticsContext = new CosmosDiagnosticsContextCore();
}
CosmosException cosmosException = CosmosExceptionFactory.Create(
documentClientException,
diagnosticsContext);
PointOperationStatistics pointOperationStatistics = new PointOperationStatistics(
activityId: cosmosException.Headers.ActivityId,
statusCode: cosmosException.StatusCode,
subStatusCode: (int)SubStatusCodes.Unknown,
responseTimeUtc: DateTime.UtcNow,
requestCharge: cosmosException.Headers.RequestCharge,
errorMessage: documentClientException.ToString(),
method: requestMessage?.Method,
requestUri: requestMessage?.RequestUriString,
requestSessionToken: requestMessage?.Headers?.Session,
responseSessionToken: cosmosException.Headers.Session);
diagnosticsContext.AddDiagnosticsInternal(pointOperationStatistics);
// if StatusCode is null it is a client business logic error and it never hit the backend, so throw
if (documentClientException.StatusCode == null)
{
throw cosmosException;
}
// if there is a status code then it came from the backend, return error as http error instead of throwing the exception
ResponseMessage responseMessage = cosmosException.ToCosmosResponseMessage(requestMessage);
if (requestMessage != null)
{
requestMessage.Properties.Remove(nameof(DocumentClientException));
requestMessage.Properties.Add(nameof(DocumentClientException), documentClientException);
}
return(responseMessage);
}
internal static ResponseMessage ToCosmosResponseMessage(this DocumentServiceResponse documentServiceResponse, RequestMessage requestMessage)
{
Debug.Assert(requestMessage != null, nameof(requestMessage));
Headers headers = documentServiceResponse.Headers.ToCosmosHeaders();
// Only record point operation stats if ClientSideRequestStats did not record the response.
CosmosClientSideRequestStatistics clientSideRequestStatistics = documentServiceResponse.RequestStats as CosmosClientSideRequestStatistics;
if (clientSideRequestStatistics == null ||
(clientSideRequestStatistics.ContactedReplicas.Count == 0 && clientSideRequestStatistics.FailedReplicas.Count == 0))
{
requestMessage.DiagnosticsContext.AddDiagnosticsInternal(new PointOperationStatistics(
activityId: headers.ActivityId,
responseTimeUtc: DateTime.UtcNow,
statusCode: documentServiceResponse.StatusCode,
subStatusCode: documentServiceResponse.SubStatusCode,
requestCharge: headers.RequestCharge,
errorMessage: null,
method: requestMessage?.Method,
requestUri: requestMessage?.RequestUri,
requestSessionToken: requestMessage?.Headers?.Session,
responseSessionToken: headers.Session));
}
// If it's considered a failure create the corresponding CosmosException
if (!documentServiceResponse.StatusCode.IsSuccess())
{
CosmosException cosmosException = CosmosExceptionFactory.Create(
documentServiceResponse,
headers,
requestMessage);
return(cosmosException.ToCosmosResponseMessage(requestMessage));
}
ResponseMessage responseMessage = new ResponseMessage(
statusCode: documentServiceResponse.StatusCode,
requestMessage: requestMessage,
headers: headers,
cosmosException: null,
diagnostics: requestMessage.DiagnosticsContext)
{
Content = documentServiceResponse.ResponseBody
};
return(responseMessage);
}
/// <summary>
/// Get the next set of results from the cosmos service
/// </summary>
/// <param name="cancellationToken">(Optional) <see cref="CancellationToken"/> representing request cancellation.</param>
/// <returns>A query response from cosmos service</returns>
public override async Task <ResponseMessage> ReadNextAsync(CancellationToken cancellationToken = default(CancellationToken))
{
CosmosDiagnosticsContext diagnostics = CosmosDiagnosticsContext.Create(this.changeFeedOptions);
using (diagnostics.GetOverallScope())
{
diagnostics.AddDiagnosticsInternal(new FeedRangeStatistics(this.FeedRangeInternal));
if (!this.lazyContainerRid.ValueInitialized)
{
using (diagnostics.CreateScope("InitializeContainerResourceId"))
{
TryCatch <string> tryInitializeContainerRId = await this.lazyContainerRid.GetValueAsync(cancellationToken);
if (!tryInitializeContainerRId.Succeeded)
{
CosmosException cosmosException = tryInitializeContainerRId.Exception.InnerException as CosmosException;
return(cosmosException.ToCosmosResponseMessage(new RequestMessage(method: null, requestUri: null, diagnosticsContext: diagnostics)));
}
}
using (diagnostics.CreateScope("InitializeContinuation"))
{
if (this.FeedRangeContinuation != null)
{
TryCatch validateContainer = this.FeedRangeContinuation.ValidateContainer(this.lazyContainerRid.Result.Result);
if (!validateContainer.Succeeded)
{
return(CosmosExceptionFactory.CreateBadRequestException(
message: validateContainer.Exception.InnerException.Message,
innerException: validateContainer.Exception.InnerException,
diagnosticsContext: diagnostics).ToCosmosResponseMessage(new RequestMessage(method: null, requestUri: null, diagnosticsContext: diagnostics)));
}
}
else
{
await this.InitializeFeedContinuationAsync(cancellationToken);
}
}
}
return(await this.ReadNextInternalAsync(diagnostics, cancellationToken));
}
}
internal static ResponseMessage ToCosmosResponseMessage(this StoreResponse storeResponse, RequestMessage requestMessage)
{
// If it's considered a failure create the corresponding CosmosException
if (!storeResponse.StatusCode.IsSuccess())
{
CosmosException cosmosException = CosmosExceptionFactory.Create(
storeResponse,
requestMessage);
return(cosmosException.ToCosmosResponseMessage(requestMessage));
}
// Is status code conversion lossy?
ResponseMessage responseMessage = new ResponseMessage((HttpStatusCode)storeResponse.Status, requestMessage);
if (storeResponse.ResponseBody != null)
{
responseMessage.Content = storeResponse.ResponseBody;
}
return(responseMessage);
}
