CosmosDB查询性能

Question

我写了最新的更新，然后从Stack Overflow收到以下错误消息:“正文限制为30000个字符；您输入了38676个字符。”

可以说，在记录我的冒险时，我非常详细，所以我已经重写了这里的内容，使其更加简洁。

我在pastebin上存储了原始帖子和更新（很长）。我不认为会有很多人读它们，但我付出了很多努力，所以不要让它们丢失。

---

我有一个包含100,000个文档的集合，用于学习如何使用CosmosDB以及进行性能测试等事情。

这些文档中每个都有一个名为Location的属性，该属性是一个GeoJSON Point。

根据文档，GeoJSON point应自动索引。

Azure Cosmos DB支持点、多边形和线串的自动索引

我已检查了集合的索引策略，并涵盖了自动点索引的条目：

{
   "automatic":true,
   "indexingMode":"Consistent",
   "includedPaths":[
      {
         "path":"/*",
         "indexes":[
            ...
            {
               "kind":"Spatial",
               "dataType":"Point"
            },
            ...                
         ]
      }
   ],
   "excludedPaths":[ ]
}

我一直在寻找列出或询问已创建的索引的方法，但我还没有找到这样的方法，因此我无法确认是否确实对该属性进行了索引。

我创建了一个 GeoJSON Polygon，然后使用它来查询我的文档。

这是我的查询：

var query = client
    .CreateDocumentQuery<TestDocument>(documentCollectionUri)
    .Where(document => document.Type == this.documentType && document.Location.Intersects(target.Area));

然后，我将查询对象传递给以下方法，以便在跟踪请求计量单位的同时获取结果：

protected async Task<IEnumerable<T>> QueryTrackingUsedRUsAsync(IQueryable<T> query)
{
    var documentQuery = query.AsDocumentQuery();
    var documents = new List<T>();

    while (documentQuery.HasMoreResults)
    {
        var response = await documentQuery.ExecuteNextAsync<T>();

        this.AddUsedRUs(response.RequestCharge);

        documents.AddRange(response);
    }

    return documents;
}

这些点的位置是随机选择的，从英国数千万个地址中选择，因此它们应该具有相当真实的分布。

多边形由16个点组成（第一个和最后一个点相同），因此它并不是非常复杂。它覆盖了英国南部的大部分地区，从伦敦往下延伸。

运行此查询的示例返回了8728个文档，使用3917.92 RU，在170717.151毫秒内完成，即不到171秒，或不到3分钟。

3918 RU / 171 s = 22.91 RU/s

我当前已将吞吐量（RU/s）设置为最低值，即400 RU/s。

我的理解是这是您保证获得的保留级别。您可以在此级别上方"突发"，但如果频繁这样做，您将被降回到您的保留级别。

显然，“查询速度”为23 RU/s远远低于吞吐量设置的400 RU/s。

我正在“本地”运行客户端，即在我的办公室而不是Azure数据中心。

每个文档的大小大约为500字节（0.5 kb）。

那么发生了什么？

我做错了什么吗？

我是否误解了关于RU/s的查询限流方式？

这是GeoSpatial索引运行的速度，因此我能得到的最佳性能吗？

GeoSpatial索引没有被使用吗？

有没有办法查看创建的索引？

有没有办法检查索引是否正在使用？

有没有办法对查询进行分析，并获取有关时间花在哪里的指标？例如，花费s按类型查找文档，s按地理空间过滤它们，花费s传输数据。

UPDATE 1

以下是我在查询中使用的多边形：

Area = new Polygon(new List<LinearRing>()
{
    new LinearRing(new List<Position>()
    {
        new Position(1.8567  ,51.3814),

        new Position(0.5329  ,51.4618),
        new Position(0.2477  ,51.2588),
        new Position(-0.5329 ,51.2579),
        new Position(-1.17   ,51.2173),
        new Position(-1.9062 ,51.1958),
        new Position(-2.5434 ,51.1614),
        new Position(-3.8672 ,51.139 ),
        new Position(-4.1578 ,50.9137),
        new Position(-4.5373 ,50.694 ),
        new Position(-5.1496 ,50.3282),
        new Position(-5.2212 ,49.9586),
        new Position(-3.7049 ,50.142 ),
        new Position(-2.1698 ,50.314 ),
        new Position(0.4669  ,50.6976),

        new Position(1.8567  ,51.3814)
    })
})

针对该多边形，我尝试了反转它的方向（因为环的方向很重要），但是查询反转后的多边形需要更长时间（我没有手头的时间）并返回了91272个结果。

此外，坐标以经度/纬度指定，因为这是 GeoJSON 期望的方式（即以 X/Y 的格式），而不是传统的纬度/经度顺序。

GeoJSON 规范指定经度应该在前面，纬度放在后面。

更新2

以下是我的一个文档的 JSON：

{
    "GeoTrigger": null,
    "SeverityTrigger": -1,
    "TypeTrigger": -1,
    "Name": "13, LONSDALE SQUARE, LONDON, N1  1EN",
    "IsEnabled": true,
    "Type": 2,
    "Location": {
        "$type": "Microsoft.Azure.Documents.Spatial.Point, Microsoft.Azure.Documents.Client",
        "type": "Point",
        "coordinates": [
            -0.1076407397346815,
            51.53970315059827
        ]
    },
    "id": "0dc2c03e-082b-4aea-93a8-79d89546c12b",
    "_rid": "EQttAMGhSQDWPwAAAAAAAA==",
    "_self": "dbs/EQttAA==/colls/EQttAMGhSQA=/docs/EQttAMGhSQDWPwAAAAAAAA==/",
    "_etag": "\"42001028-0000-0000-0000-594943fe0000\"",
    "_attachments": "attachments/",
    "_ts": 1497973747
}

更新 3

我创建了一个最小化的问题复现，发现问题不再出现了。

这表明问题确实出在我自己的代码中。

我开始检查原始代码和复现代码之间的所有差异，最终发现一些对我来说看起来相当无害的东西实际上有很大的影响。而且幸运的是，那段代码根本不需要使用，所以修复起来很容易，只需简单地不使用那段代码即可。

曾经我使用了一个自定义的ContractResolver，但一旦不再需要它，我就没有将其删除。

以下是有问题的复现代码：

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Spatial;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

namespace Repro.Cli
{
    public class Program
    {
        static void Main(string[] args)
        {
            JsonConvert.DefaultSettings = () =>
            {
                return new JsonSerializerSettings
                {
                    ContractResolver = new PropertyNameMapContractResolver(new Dictionary<string, string>()
                    {
                        { "ID", "id" }
                    })
                };
            };

            //AJ: Init logging
            Trace.AutoFlush = true;
            Trace.Listeners.Add(new ConsoleTraceListener());
            Trace.Listeners.Add(new TextWriterTraceListener("trace.log"));

            //AJ: Increase availible threads
            //AJ: https://learn.microsoft.com/en-us/azure/storage/storage-performance-checklist#subheading10
            //AJ: https://github.com/Azure/azure-documentdb-dotnet/blob/master/samples/documentdb-benchmark/Program.cs
            var minThreadPoolSize = 100;
            ThreadPool.SetMinThreads(minThreadPoolSize, minThreadPoolSize);

            //AJ: https://learn.microsoft.com/en-us/azure/cosmos-db/performance-tips
            //AJ: gcServer enabled in app.config
            //AJ: Prefer 32-bit disabled in project properties

            //AJ: DO IT
            var program = new Program();

            Trace.TraceInformation($"Starting @ {DateTime.UtcNow}");
            program.RunAsync().Wait();
            Trace.TraceInformation($"Finished @ {DateTime.UtcNow}");

            //AJ: Wait for user to exit
            Console.WriteLine();
            Console.WriteLine("Hit enter to exit...");
            Console.ReadLine();
        }

        public async Task RunAsync()
        {
            using (new CodeTimer())
            {
                var client = await this.GetDocumentClientAsync();
                var documentCollectionUri = UriFactory.CreateDocumentCollectionUri(ConfigurationManager.AppSettings["databaseID"], ConfigurationManager.AppSettings["collectionID"]);

                //AJ: Prepare Test Documents
                var documentCount = 10000; //AJ: 10,000
                var documentsForUpsert = this.GetDocuments(documentCount);
                await this.UpsertDocumentsAsync(client, documentCollectionUri, documentsForUpsert);

                var allDocuments = this.GetAllDocuments(client, documentCollectionUri);

                var area = this.GetArea();
                var documentsInArea = this.GetDocumentsInArea(client, documentCollectionUri, area);
            }
        }

        private async Task<DocumentClient> GetDocumentClientAsync()
        {
            using (new CodeTimer())
            {
                var serviceEndpointUri = new Uri(ConfigurationManager.AppSettings["serviceEndpoint"]);
                var authKey = ConfigurationManager.AppSettings["authKey"];

                var connectionPolicy = new ConnectionPolicy
                {
                    ConnectionMode = ConnectionMode.Direct,
                    ConnectionProtocol = Protocol.Tcp,
                    RequestTimeout = new TimeSpan(1, 0, 0),
                    RetryOptions = new RetryOptions
                    {
                        MaxRetryAttemptsOnThrottledRequests = 10,
                        MaxRetryWaitTimeInSeconds = 60
                    }
                };

                var client = new DocumentClient(serviceEndpointUri, authKey, connectionPolicy);

                await client.OpenAsync();

                return client;
            }
        }

        private List<TestDocument> GetDocuments(int count)
        {
            using (new CodeTimer())
            {
                return External.CreateDocuments(count);
            }
        }

        private async Task UpsertDocumentsAsync(DocumentClient client, Uri documentCollectionUri, List<TestDocument> documents)
        {
            using (new CodeTimer())
            {
                //TODO: AJ: Parallelise
                foreach (var document in documents)
                {
                    await client.UpsertDocumentAsync(documentCollectionUri, document);
                }
            }
        }

        private List<TestDocument> GetAllDocuments(DocumentClient client, Uri documentCollectionUri)
        {
            using (new CodeTimer())
            {
                var query = client
                    .CreateDocumentQuery<TestDocument>(documentCollectionUri, new FeedOptions()
                    {
                        MaxItemCount = 1000
                    });

                var documents = query.ToList();

                return documents;
            }
        }

        private Polygon GetArea()
        {
            //AJ: Longitude,Latitude i.e. X/Y
            //AJ: Ring orientation matters 
            return new Polygon(new List<LinearRing>()
            {
                new LinearRing(new List<Position>()
                {
                    new Position(1.8567  ,51.3814),

                    new Position(0.5329  ,51.4618),
                    new Position(0.2477  ,51.2588),
                    new Position(-0.5329 ,51.2579),
                    new Position(-1.17   ,51.2173),
                    new Position(-1.9062 ,51.1958),
                    new Position(-2.5434 ,51.1614),
                    new Position(-3.8672 ,51.139 ),
                    new Position(-4.1578 ,50.9137),
                    new Position(-4.5373 ,50.694 ),
                    new Position(-5.1496 ,50.3282),
                    new Position(-5.2212 ,49.9586),
                    new Position(-3.7049 ,50.142 ),
                    new Position(-2.1698 ,50.314 ),
                    new Position(0.4669  ,50.6976),

                    //AJ: Last point must be the same as first point
                    new Position(1.8567  ,51.3814)
                })
            });
        }

        private List<TestDocument> GetDocumentsInArea(DocumentClient client, Uri documentCollectionUri, Polygon area)
        {
            using (new CodeTimer())
            {
                var query = client
                    .CreateDocumentQuery<TestDocument>(documentCollectionUri, new FeedOptions()
                    {
                        MaxItemCount = 1000
                    })
                    .Where(document => document.Location.Intersects(area));

                var documents = query.ToList();

                return documents;
            }
        }
    }

    public class TestDocument : Resource
    {
        public string Name { get; set; }
        public Point Location { get; set; } //AJ: Longitude,Latitude i.e. X/Y

        public TestDocument()
        {
            this.Id = Guid.NewGuid().ToString("N");
        }
    }

    //AJ: This should be "good enough". The times being recorded are seconds or minutes.
    public class CodeTimer : IDisposable
    {
        private Action<TimeSpan> reportFunction;
        private Stopwatch stopwatch = new Stopwatch();

        public CodeTimer([CallerMemberName]string name = "")
            : this((ellapsed) =>
            {
                Trace.TraceInformation($"{name} took {ellapsed}, or {ellapsed.TotalMilliseconds} ms.");
            })
        { }

        public CodeTimer(Action<TimeSpan> report)
        {
            this.reportFunction = report;
            this.stopwatch.Start();
        }

        public void Dispose()
        {
            this.stopwatch.Stop();
            this.reportFunction(this.stopwatch.Elapsed);
        }
    }

    public class PropertyNameMapContractResolver : DefaultContractResolver
    {
        private Dictionary<string, string> propertyNameMap;

        public PropertyNameMapContractResolver(Dictionary<string, string> propertyNameMap)
        {
            this.propertyNameMap = propertyNameMap;
        }

        protected override string ResolvePropertyName(string propertyName)
        {
            if (this.propertyNameMap.TryGetValue(propertyName, out string resolvedName))
                return resolvedName;

            return base.ResolvePropertyName(propertyName);
        }
    }
}

- user310988

---

是的，我已将其包含在代码形式中，并添加了有关环向的信息。 - user310988

请问您能提供一份您的收集样本文件吗？ - Amor

是的，我已经添加了来自Azure Portal数据浏览器的文档的JSON表示。 - user310988

我目前正在创建一个“重现”控制台应用程序，使用更易访问的代码格式。希望这能帮助突出我在自己这边做错的任何事情。 - user310988

@DavidMakogon 感谢您关注此问题。我已确认自己的错误，并希望 CosmosDB 正是我所需要的。 - user310988

Answer 1

我正在使用自定义的ContractResolver，显然这对来自.Net SDK的DocumentDB类的性能产生了很大的影响。

以下是我设置ContractResolver的方式：

JsonConvert.DefaultSettings = () =>
{
    return new JsonSerializerSettings
    {
        ContractResolver = new PropertyNameMapContractResolver(new Dictionary<string, string>()
        {
            { "ID", "id" }
        })
    };
};

这是它的实现方式：

public class PropertyNameMapContractResolver : DefaultContractResolver
{
    private Dictionary<string, string> propertyNameMap;

    public PropertyNameMapContractResolver(Dictionary<string, string> propertyNameMap)
    {
        this.propertyNameMap = propertyNameMap;
    }

    protected override string ResolvePropertyName(string propertyName)
    {
        if (this.propertyNameMap.TryGetValue(propertyName, out string resolvedName))
            return resolvedName;

        return base.ResolvePropertyName(propertyName);
    }
}

解决方案很简单，不要设置JsonConvert.DefaultSettings，这样就不会使用ContractResolver。

结果：

我能在21799.0221毫秒内执行空间查询，相当于22秒。

之前需要170717.151毫秒，即2分钟50秒。

快了约8倍！

- user310988