public void TestParseStringWithTrailingUnknownField()
{
string delimitedString = $"thisIsNotAKnownField=asdf";
BackendMetrics expected = new BackendMetrics(
default(long),
default(long),
default(long),
default(long),
default(double),
default(TimeSpan),
new QueryPreparationTimes(
default(TimeSpan),
default(TimeSpan),
default(TimeSpan),
default(TimeSpan)),
default(TimeSpan),
default(TimeSpan),
default(TimeSpan),
new RuntimeExecutionTimes(
default(TimeSpan),
default(TimeSpan),
default(TimeSpan)),
default(TimeSpan));
BackendMetricsTests.ValidateParse(delimitedString, expected);
}
public void TestParseStringWithMissingFields()
{
TimeSpan totalExecutionTime = TimeSpan.FromTicks((long)(TimeSpan.TicksPerMillisecond * 33.67));
string delimitedString = $"totalExecutionTimeInMs={totalExecutionTime.TotalMilliseconds}";
BackendMetrics expected = new BackendMetrics(
default(long),
default(long),
default(long),
default(long),
default(double),
totalExecutionTime,
new QueryPreparationTimes(
default(TimeSpan),
default(TimeSpan),
default(TimeSpan),
default(TimeSpan)),
default(TimeSpan),
default(TimeSpan),
default(TimeSpan),
new RuntimeExecutionTimes(
default(TimeSpan),
default(TimeSpan),
default(TimeSpan)),
default(TimeSpan));
BackendMetricsTests.ValidateParse(delimitedString, expected);
}
public void TestAccumulator()
{
BackendMetrics.Accumulator accumulator = new BackendMetrics.Accumulator();
accumulator = accumulator.Accumulate(MockBackendMetrics);
accumulator = accumulator.Accumulate(MockBackendMetrics);
BackendMetrics backendMetricsFromAddition = BackendMetrics.Accumulator.ToBackendMetrics(accumulator);
BackendMetrics expected = new BackendMetrics(
retrievedDocumentCount * 2,
retrievedDocumentSize * 2,
outputDocumentCount * 2,
outputDocumentSize * 2,
indexHitRatio,
totalExecutionTime * 2,
new QueryPreparationTimes(
queryCompileTime * 2,
logicalPlanBuildTime * 2,
physicalPlanBuildTime * 2,
queryOptimizationTime * 2),
indexLookupTime * 2,
documentLoadTime * 2,
vmExecutionTime * 2,
new RuntimeExecutionTimes(
(totalExecutionTime - systemFunctionExecuteTime - userFunctionExecuteTime) * 2,
systemFunctionExecuteTime * 2,
userFunctionExecuteTime * 2),
documentWriteTime * 2);
BackendMetricsTests.ValidateBackendMetricsEquals(expected, backendMetricsFromAddition);
}
private static void ValidateBackendMetricsEquals(BackendMetrics expected, BackendMetrics actual)
{
Assert.AreEqual(expected.DocumentLoadTime, actual.DocumentLoadTime);
Assert.AreEqual(expected.DocumentWriteTime, actual.DocumentWriteTime);
Assert.AreEqual(expected.OutputDocumentCount, actual.OutputDocumentCount);
Assert.AreEqual(expected.OutputDocumentSize, actual.OutputDocumentSize);
Assert.AreEqual(expected.RetrievedDocumentCount, actual.RetrievedDocumentCount);
Assert.AreEqual(expected.RetrievedDocumentSize, actual.RetrievedDocumentSize);
Assert.AreEqual(expected.IndexHitRatio, actual.IndexHitRatio);
Assert.AreEqual(expected.QueryPreparationTimes.QueryCompilationTime, actual.QueryPreparationTimes.QueryCompilationTime);
Assert.AreEqual(expected.QueryPreparationTimes.LogicalPlanBuildTime, actual.QueryPreparationTimes.LogicalPlanBuildTime);
Assert.AreEqual(expected.QueryPreparationTimes.PhysicalPlanBuildTime, actual.QueryPreparationTimes.PhysicalPlanBuildTime);
Assert.AreEqual(expected.QueryPreparationTimes.QueryOptimizationTime, actual.QueryPreparationTimes.QueryOptimizationTime);
Assert.AreEqual(expected.RuntimeExecutionTimes.SystemFunctionExecutionTime, actual.RuntimeExecutionTimes.SystemFunctionExecutionTime);
Assert.AreEqual(expected.RuntimeExecutionTimes.UserDefinedFunctionExecutionTime, actual.RuntimeExecutionTimes.UserDefinedFunctionExecutionTime);
Assert.AreEqual(expected.TotalTime, actual.TotalTime);
Assert.AreEqual(expected.VMExecutionTime, actual.VMExecutionTime);
}
protected override async Task <DocumentFeedResponse <CosmosElement> > ExecuteInternalAsync(CancellationToken token)
{
CollectionCache collectionCache = await this.Client.GetCollectionCacheAsync();
PartitionKeyRangeCache partitionKeyRangeCache = await this.Client.GetPartitionKeyRangeCacheAsync();
IDocumentClientRetryPolicy retryPolicyInstance = this.Client.ResetSessionTokenRetryPolicy.GetRequestPolicy();
retryPolicyInstance = new InvalidPartitionExceptionRetryPolicy(retryPolicyInstance);
if (base.ResourceTypeEnum.IsPartitioned())
{
retryPolicyInstance = new PartitionKeyRangeGoneRetryPolicy(
collectionCache,
partitionKeyRangeCache,
PathsHelper.GetCollectionPath(base.ResourceLink),
retryPolicyInstance);
}
return(await BackoffRetryUtility <DocumentFeedResponse <CosmosElement> > .ExecuteAsync(
async() =>
{
this.fetchExecutionRangeAccumulator.BeginFetchRange();
++this.retries;
Tuple <DocumentFeedResponse <CosmosElement>, string> responseAndPartitionIdentifier = await this.ExecuteOnceAsync(retryPolicyInstance, token);
DocumentFeedResponse <CosmosElement> response = responseAndPartitionIdentifier.Item1;
string partitionIdentifier = responseAndPartitionIdentifier.Item2;
if (!string.IsNullOrEmpty(response.ResponseHeaders[HttpConstants.HttpHeaders.QueryMetrics]))
{
this.fetchExecutionRangeAccumulator.EndFetchRange(
partitionIdentifier,
response.ActivityId,
response.Count,
this.retries);
response = new DocumentFeedResponse <CosmosElement>(
response,
response.Count,
response.Headers,
response.UseETagAsContinuation,
new Dictionary <string, QueryMetrics>
{
{
partitionIdentifier,
new QueryMetrics(
BackendMetrics.ParseFromDelimitedString(response.ResponseHeaders[HttpConstants.HttpHeaders.QueryMetrics]),
IndexUtilizationInfo.CreateFromString(response.ResponseHeaders[HttpConstants.HttpHeaders.IndexUtilization]),
new ClientSideMetrics(
this.retries,
response.RequestCharge,
this.fetchExecutionRangeAccumulator.GetExecutionRanges()))
}
},
response.RequestStatistics,
response.DisallowContinuationTokenMessage,
response.ResponseLengthBytes);
}
this.retries = -1;
return response;
},
retryPolicyInstance,
token));
}
private static void ValidateParse(string delimitedString, BackendMetrics expected)
{
Assert.IsTrue(BackendMetricsParser.TryParse(delimitedString, out BackendMetrics actual));
BackendMetricsTests.ValidateBackendMetricsEquals(expected, actual);
}
