DocumentDB performance issues

Question

When running from DocumentDB queries from C# code on my local computer a simple DocumentDB query takes about 0.5 seconds in average. Another example, getting a reference to a document collection takes about 0.7 seconds in average. Is this to be expected? Below is my code for checking if a collection exists, it is pretty straight forward - but is there any way of improving the bad performance?

// Create a new instance of the DocumentClient
var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey);

// Get the database with the id=FamilyRegistry
var database = client.CreateDatabaseQuery().Where(db => db.Id == "FamilyRegistry").AsEnumerable().FirstOrDefault();

var stopWatch = new Stopwatch();
stopWatch.Start();

// Get the document collection with the id=FamilyCollection
var documentCollection = client.CreateDocumentCollectionQuery("dbs/" 
    + database.Id).Where(c => c.Id == "FamilyCollection").AsEnumerable().FirstOrDefault();

stopWatch.Stop();

// Get the elapsed time as a TimeSpan value.
var ts = stopWatch.Elapsed;

// Format and display the TimeSpan value.
var elapsedTime = String.Format("{0:00} seconds, {1:00} milliseconds",
    ts.Seconds,
    ts.Milliseconds );

Console.WriteLine("Time taken to get a document collection: " + elapsedTime);
Console.ReadKey();

Average output on local computer:

Time taken to get a document collection: 0 seconds, 752 milliseconds

In another piece of my code I'm doing 20 small document updates that are about 400 bytes each in JSON size and it still takes 12 seconds in total. I'm only running from my development environment but I was expecting better performance.

Answer 1

In short, this can be done end to end in ~9 milliseconds with DocumentDB. I'll walk through the changes required, and why/how they impact results below.

The very first query always takes longer in DocumentDB because it does some setup work (fetching physical addresses of DocumentDB partitions). The next couple requests take a little bit longer to warm the connection pools. The subsequent queries will be as fast as your network (the latency of reads in DocumentDB is very low due to SSD storage).

For example, if you modify your code above to measure, for example 10 readings instead of just the first one like shown below:

using (DocumentClient client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey))
{
    long totalRequests = 10;

    var database = client.CreateDatabaseQuery().Where(db => db.Id == "FamilyRegistry").AsEnumerable().FirstOrDefault();

    Stopwatch watch = new Stopwatch();
    for (int i = 0; i < totalRequests; i++)
    {
        watch.Start();
        var documentCollection = client.CreateDocumentCollectionQuery("dbs/"+ database.Id)
            .Where(c => c.Id == "FamilyCollection").AsEnumerable().FirstOrDefault();

        Console.WriteLine("Finished read {0} in {1}ms ", i, watch.ElapsedMilliseconds);
        watch.Reset();
    }
}

Console.ReadKey();

I get the following results running from my desktop in Redmond against the Azure West US data center, i.e. about 50 milliseconds. These numbers may vary based on the network connectivity and distance of your client from the Azure DC hosting DocumentDB:

Finished read 0 in 217ms
Finished read 1 in 46ms
Finished read 2 in 51ms
Finished read 3 in 47ms
Finished read 4 in 46ms
Finished read 5 in 93ms
Finished read 6 in 48ms
Finished read 7 in 45ms
Finished read 8 in 45ms
Finished read 9 in 51ms

Next, I switch to Direct/TCP connectivity from the default of Gateway to improve the latency from two hops to one, i.e., change the initialization code to:

using (DocumentClient client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey, new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp }))

Now the operation to find the collection by ID completes within 23 milliseconds:

Finished read 0 in 197ms
Finished read 1 in 117ms
Finished read 2 in 23ms
Finished read 3 in 23ms
Finished read 4 in 25ms
Finished read 5 in 23ms
Finished read 6 in 31ms
Finished read 7 in 23ms
Finished read 8 in 23ms
Finished read 9 in 23ms

How about when you run the same results from an Azure VM or Worker Role also running in the same Azure DC? The same operation completes with about 9 milliseconds!

Finished read 0 in 140ms
Finished read 1 in 10ms
Finished read 2 in 8ms
Finished read 3 in 9ms
Finished read 4 in 9ms
Finished read 5 in 9ms
Finished read 6 in 9ms
Finished read 7 in 9ms
Finished read 8 in 10ms
Finished read 9 in 8ms
Finished read 9 in 9ms

So, to summarize:

• For performance measurements, please allow for a few measurement samples to account for startup/initialization of the DocumentDB client.
• Please use TCP/Direct connectivity for lowest latency.
• When possible, run within the same Azure region.
• If you follow these steps, you can get great performance and you'll be able to get the best performance numbers with DocumentDB.