Merge branch 'master' of github.com:Squidex/squidex

4 years ago · cb7b1014e8
31 changed files with 89 additions and 117 deletions
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetFolderRepository.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetFolderRepository.cs
@ -45,7 +45,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IResultList<IAssetFolderEntity>> QueryAsync(DomainId appId, DomainId parentId,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetFolderRepository>("QueryAsyncByQuery"))
+            using (Telemetry.Activities.StartActivity("MongoAssetFolderRepository/QueryAsync"))
            {
                var filter = BuildFilter(appId, parentId);

@ -60,7 +60,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IReadOnlyList<DomainId>> QueryChildIdsAsync(DomainId appId, DomainId parentId,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetFolderRepository/QueryChildIdsAsync"))
            {
                var filter = BuildFilter(appId, parentId);

@ -77,7 +77,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IAssetFolderEntity?> FindAssetFolderAsync(DomainId appId, DomainId id,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetFolderRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetFolderRepository/FindAssetFolderAsync"))
            {
                var documentId = DomainId.Combine(appId, id);

--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetFolderRepository_SnapshotStore.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetFolderRepository_SnapshotStore.cs
@ -24,7 +24,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
    {
        async Task<(AssetFolderDomainObject.State Value, bool Valid, long Version)> ISnapshotStore<AssetFolderDomainObject.State>.ReadAsync(DomainId key)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetFolderRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetFolderRepository/ReadAsync"))
            {
                var existing =
                    await Collection.Find(x => x.DocumentId == key)
@ -41,7 +41,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets

        async Task ISnapshotStore<AssetFolderDomainObject.State>.WriteAsync(DomainId key, AssetFolderDomainObject.State value, long oldVersion, long newVersion)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetFolderRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetFolderRepository/WriteAsync"))
            {
                var entity = Map(value);

@ -51,7 +51,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets

        async Task ISnapshotStore<AssetFolderDomainObject.State>.WriteManyAsync(IEnumerable<(DomainId Key, AssetFolderDomainObject.State Value, long Version)> snapshots)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetFolderRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetFolderRepository/WriteManyAsync"))
            {
                var updates = snapshots.Select(Map).Select(x =>
                    new ReplaceOneModel<MongoAssetFolderEntity>(
@ -73,7 +73,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        async Task ISnapshotStore<AssetFolderDomainObject.State>.ReadAllAsync(Func<AssetFolderDomainObject.State, long, Task> callback,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetFolderRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetFolderRepository/ReadAllAsync"))
            {
                await Collection.Find(new BsonDocument(), Batching.Options).ForEachAsync(x => callback(Map(x), x.Version), ct);
            }
@ -81,7 +81,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets

        async Task ISnapshotStore<AssetFolderDomainObject.State>.RemoveAsync(DomainId key)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetFolderRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetFolderRepository/RemoveAsync"))
            {
                await Collection.DeleteOneAsync(x => x.DocumentId == key);
            }
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetRepository.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetRepository.cs
@ -90,7 +90,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IResultList<IAssetEntity>> QueryAsync(DomainId appId, DomainId? parentId, Q q,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>("QueryAsyncByQuery"))
+            using (Telemetry.Activities.StartActivity("ContentQueryService/QueryAsync"))
            {
                try
                {
@ -152,7 +152,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IReadOnlyList<DomainId>> QueryIdsAsync(DomainId appId, HashSet<DomainId> ids,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>("QueryAsyncByIds"))
+            using (Telemetry.Activities.StartActivity("ContentQueryService/QueryIdsAsync"))
            {
                var assetEntities =
                    await Collection.Find(BuildFilter(appId, ids)).Only(x => x.Id)
@ -167,7 +167,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IReadOnlyList<DomainId>> QueryChildIdsAsync(DomainId appId, DomainId parentId,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/QueryChildIdsAsync"))
            {
                var assetEntities =
                    await Collection.Find(x => x.IndexedAppId == appId && !x.IsDeleted && x.ParentId == parentId).Only(x => x.Id)
@ -182,7 +182,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IAssetEntity?> FindAssetByHashAsync(DomainId appId, string hash, string fileName, long fileSize,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/FindAssetByHashAsync"))
            {
                var assetEntity =
                    await Collection.Find(x => x.IndexedAppId == appId && !x.IsDeleted && x.FileHash == hash && x.FileName == fileName && x.FileSize == fileSize)
@ -195,7 +195,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IAssetEntity?> FindAssetBySlugAsync(DomainId appId, string slug,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/FindAssetBySlugAsync"))
            {
                var assetEntity =
                    await Collection.Find(x => x.IndexedAppId == appId && !x.IsDeleted && x.Slug == slug)
@ -208,7 +208,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IAssetEntity?> FindAssetAsync(DomainId appId, DomainId id,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/FindAssetAsync"))
            {
                var documentId = DomainId.Combine(appId, id);

@ -223,7 +223,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        public async Task<IAssetEntity?> FindAssetAsync(DomainId id,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/FindAssetAsync"))
            {
                var assetEntity =
                    await Collection.Find(x => x.Id == id && !x.IsDeleted)
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetRepository_SnapshotStore.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Assets/MongoAssetRepository_SnapshotStore.cs
@ -24,7 +24,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
    {
        async Task<(AssetDomainObject.State Value, bool Valid, long Version)> ISnapshotStore<AssetDomainObject.State>.ReadAsync(DomainId key)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetRepository/ReadAsync"))
            {
                var existing =
                    await Collection.Find(x => x.DocumentId == key)
@ -41,7 +41,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets

        async Task ISnapshotStore<AssetDomainObject.State>.WriteAsync(DomainId key, AssetDomainObject.State value, long oldVersion, long newVersion)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetRepository/WriteAsync"))
            {
                var entity = Map(value);

@ -51,7 +51,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets

        async Task ISnapshotStore<AssetDomainObject.State>.WriteManyAsync(IEnumerable<(DomainId Key, AssetDomainObject.State Value, long Version)> snapshots)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetFolderRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetRepository/WriteManyAsync"))
            {
                var updates = snapshots.Select(Map).Select(x =>
                    new ReplaceOneModel<MongoAssetEntity>(
@ -73,7 +73,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets
        async Task ISnapshotStore<AssetDomainObject.State>.ReadAllAsync(Func<AssetDomainObject.State, long, Task> callback,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetRepository/ReadAllAsync"))
            {
                await Collection.Find(new BsonDocument(), Batching.Options).ForEachAsync(x => callback(Map(x), x.Version), ct);
            }
@ -81,7 +81,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Assets

        async Task ISnapshotStore<AssetDomainObject.State>.RemoveAsync(DomainId key)
        {
-            using (Telemetry.Activities.StartMethod<MongoAssetRepository>())
+            using (Telemetry.Activities.StartActivity("MongoAssetRepository/RemoveAsync"))
            {
                await Collection.DeleteOneAsync(x => x.DocumentId == key);
            }
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentCollection.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentCollection.cs
@ -106,7 +106,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
        public async Task<IResultList<IContentEntity>> QueryAsync(IAppEntity app, List<ISchemaEntity> schemas, Q q,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentCollection/QueryAsync"))
            {
                if (q.Ids != null && q.Ids.Count > 0)
                {
@ -135,7 +135,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
        public async Task<IResultList<IContentEntity>> QueryAsync(IAppEntity app, ISchemaEntity schema, Q q,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentCollection/QueryAsync"))
            {
                if (q.Ids != null && q.Ids.Count > 0)
                {
@ -159,7 +159,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
        public async Task<IContentEntity?> FindContentAsync(ISchemaEntity schema, DomainId id,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentCollection/FindContentAsync"))
            {
                return await queryBdId.QueryAsync(schema, id, ct);
            }
@ -168,7 +168,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
        public async Task QueryScheduledWithoutDataAsync(Instant now, Func<IContentEntity, Task> callback,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentCollection/QueryScheduledWithoutDataAsync"))
            {
                await queryScheduled.QueryAsync(now, callback, ct);
            }
@ -177,7 +177,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
        public async Task<IReadOnlyList<(DomainId SchemaId, DomainId Id, Status Status)>> QueryIdsAsync(DomainId appId, HashSet<DomainId> ids,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentCollection/QueryIdsAsync"))
            {
                return await queryByIds.QueryIdsAsync(appId, ids, ct);
            }
@ -186,7 +186,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
        public async Task<IReadOnlyList<(DomainId SchemaId, DomainId Id, Status Status)>> QueryIdsAsync(DomainId appId, DomainId schemaId, FilterNode<ClrValue> filterNode,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentCollection/QueryIdsAsync"))
            {
                return await queryByQuery.QueryIdsAsync(appId, schemaId, filterNode, ct);
            }
@ -195,7 +195,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
        public async Task<bool> HasReferrersAsync(DomainId appId, DomainId contentId,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentCollection/HasReferrersAsync"))
            {
                return await queryReferrers.CheckExistsAsync(appId, contentId, ct);
            }
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentRepository_SnapshotStore.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentRepository_SnapshotStore.cs
@ -28,7 +28,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents

        async Task<(ContentDomainObject.State Value, bool Valid, long Version)> ISnapshotStore<ContentDomainObject.State>.ReadAsync(DomainId key)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentRepository/ReadAsync"))
            {
                var version = await collectionAll.FindVersionAsync(key);

@ -38,7 +38,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents

        async Task ISnapshotStore<ContentDomainObject.State>.ClearAsync()
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentRepository/ClearAsync"))
            {
                await collectionAll.ClearAsync();
                await collectionPublished.ClearAsync();
@ -47,7 +47,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents

        async Task ISnapshotStore<ContentDomainObject.State>.RemoveAsync(DomainId key)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentRepository/RemoveAsync"))
            {
                await collectionAll.RemoveAsync(key);
                await collectionPublished.RemoveAsync(key);
@ -56,7 +56,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents

        async Task ISnapshotStore<ContentDomainObject.State>.WriteAsync(DomainId key, ContentDomainObject.State value, long oldVersion, long newVersion)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentRepository/WriteAsync"))
            {
                if (value.SchemaId.Id == DomainId.Empty)
                {
@ -71,7 +71,7 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents

        async Task ISnapshotStore<ContentDomainObject.State>.WriteManyAsync(IEnumerable<(DomainId Key, ContentDomainObject.State Value, long Version)> snapshots)
        {
-            using (Telemetry.Activities.StartMethod<MongoContentRepository>())
+            using (Telemetry.Activities.StartActivity("MongoContentRepository/WriteManyAsync"))
            {
                var entitiesPublished = new List<MongoContentEntity>();
                var entitiesAll = new List<MongoContentEntity>();
--- a/backend/src/Squidex.Domain.Apps.Entities/Apps/Indexes/AppsIndex.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Apps/Indexes/AppsIndex.cs
@ -76,7 +76,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes

        public async Task<List<IAppEntity>> GetAppsAsync()
        {
-            using (Telemetry.Activities.StartMethod<AppsIndex>())
+            using (Telemetry.Activities.StartActivity("AppProvider/GetAppsAsync"))
            {
                var ids = await GetAppIdsAsync();

@ -90,7 +90,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes

        public async Task<List<IAppEntity>> GetAppsForUserAsync(string userId, PermissionSet permissions)
        {
-            using (Telemetry.Activities.StartMethod<AppsIndex>())
+            using (Telemetry.Activities.StartActivity("AppProvider/GetAppsForUserAsync"))
            {
                var ids =
                    await Task.WhenAll(
@ -108,7 +108,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes

        public async Task<IAppEntity?> GetAppByNameAsync(string name, bool canCache = false)
        {
-            using (Telemetry.Activities.StartMethod<AppsIndex>())
+            using (Telemetry.Activities.StartActivity("AppProvider/GetAppByNameAsync"))
            {
                if (canCache)
                {
@ -131,7 +131,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes

        public async Task<IAppEntity?> GetAppAsync(DomainId appId, bool canCache)
        {
-            using (Telemetry.Activities.StartMethod<AppsIndex>())
+            using (Telemetry.Activities.StartActivity("AppProvider/GetAppAsync"))
            {
                if (canCache)
                {
@ -154,7 +154,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes

        private async Task<List<DomainId>> GetAppIdsByUserAsync(string userId)
        {
-            using (Telemetry.Activities.StartMethod<AppProvider>())
+            using (Telemetry.Activities.StartActivity("AppProvider/GetAppIdsByUserAsync"))
            {
                return await grainFactory.GetGrain<IAppsByUserIndexGrain>(userId).GetIdsAsync();
            }
@ -162,7 +162,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes

        private async Task<List<DomainId>> GetAppIdsAsync()
        {
-            using (Telemetry.Activities.StartMethod<AppProvider>())
+            using (Telemetry.Activities.StartActivity("AppProvider/GetAllAppIdsAsync"))
            {
                return await grainFactory.GetGrain<IAppsByNameIndexGrain>(SingleGrain.Id).GetIdsAsync();
            }
@ -170,7 +170,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes

        private async Task<List<DomainId>> GetAppIdsAsync(string[] names)
        {
-            using (Telemetry.Activities.StartMethod<AppProvider>())
+            using (Telemetry.Activities.StartActivity("AppProvider/GetAppIdsAsync"))
            {
                return await grainFactory.GetGrain<IAppsByNameIndexGrain>(SingleGrain.Id).GetIdsAsync(names);
            }
@ -178,7 +178,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes

        private async Task<DomainId> GetAppIdAsync(string name)
        {
-            using (Telemetry.Activities.StartMethod<AppProvider>())
+            using (Telemetry.Activities.StartActivity("AppProvider/GetAppIdAsync"))
            {
                return await grainFactory.GetGrain<IAppsByNameIndexGrain>(SingleGrain.Id).GetIdAsync(name);
            }
--- a/backend/src/Squidex.Domain.Apps.Entities/Assets/Queries/AssetEnricher.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Assets/Queries/AssetEnricher.cs
@ -47,7 +47,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
            Guard.NotNull(assets, nameof(assets));
            Guard.NotNull(context, nameof(context));

-            using (Telemetry.Activities.StartMethod<AssetEnricher>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/EnrichAsync"))
            {
                var results = assets.Select(x => SimpleMapper.Map(x, new AssetEntity())).ToList();

--- a/backend/src/Squidex.Domain.Apps.Entities/Assets/Queries/AssetLoader.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Assets/Queries/AssetLoader.cs
@ -23,7 +23,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries

        public async Task<IAssetEntity?> GetAsync(DomainId appId, DomainId id, long version)
        {
-            using (Telemetry.Activities.StartMethod<AssetLoader>())
+            using (Telemetry.Activities.StartActivity("AssetLoader/GetAsync"))
            {
                var key = DomainId.Combine(appId, id);

--- a/backend/src/Squidex.Domain.Apps.Entities/Assets/Queries/AssetQueryParser.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Assets/Queries/AssetQueryParser.cs
@ -47,7 +47,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
            Guard.NotNull(context, nameof(context));
            Guard.NotNull(q, nameof(q));

-            using (Telemetry.Activities.StartMethod<AssetQueryParser>())
+            using (Telemetry.Activities.StartActivity("AssetQueryParser/ParseAsync"))
            {
                var query = ParseClrQuery(q);

--- a/backend/src/Squidex.Domain.Apps.Entities/Assets/Queries/AssetQueryService.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Assets/Queries/AssetQueryService.cs
@ -44,7 +44,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
        public async Task<IReadOnlyList<IAssetFolderEntity>> FindAssetFolderAsync(DomainId appId, DomainId id,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<AssetQueryService>())
+            using (Telemetry.Activities.StartActivity("AssetQueryService/FindAssetFolderAsync"))
            {
                var result = new List<IAssetFolderEntity>();

@ -70,7 +70,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
        public async Task<IResultList<IAssetFolderEntity>> QueryAssetFoldersAsync(DomainId appId, DomainId parentId,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<AssetQueryService>())
+            using (Telemetry.Activities.StartActivity("AssetQueryService/QueryAssetFoldersAsync"))
            {
                var assetFolders = await QueryFoldersCoreAsync(appId, parentId, ct);

@ -81,7 +81,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
        public async Task<IResultList<IAssetFolderEntity>> QueryAssetFoldersAsync(Context context, DomainId parentId,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<AssetQueryService>())
+            using (Telemetry.Activities.StartActivity("AssetQueryService/QueryAssetFoldersAsync"))
            {
                var assetFolders = await QueryFoldersCoreAsync(context, parentId, ct);

@ -94,7 +94,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
        {
            Guard.NotNull(context, nameof(context));

-            using (Telemetry.Activities.StartMethod<AssetQueryService>())
+            using (Telemetry.Activities.StartActivity("AssetQueryService/FindByHashAsync"))
            {
                var asset = await FindByHashCoreAsync(context, hash, fileName, fileSize, ct);

@ -112,7 +112,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
        {
            Guard.NotNull(context, nameof(context));

-            using (Telemetry.Activities.StartMethod<AssetQueryService>())
+            using (Telemetry.Activities.StartActivity("AssetQueryService/FindBySlugAsync"))
            {
                var asset = await FindBySlugCoreAsync(context, slug, ct);

@ -130,7 +130,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
        {
            Guard.NotNull(context, nameof(context));

-            using (Telemetry.Activities.StartMethod<AssetQueryService>())
+            using (Telemetry.Activities.StartActivity("AssetQueryService/FindGlobalAsync"))
            {
                var asset = await FindCoreAsync(id, ct);

@ -148,7 +148,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
        {
            Guard.NotNull(context, nameof(context));

-            using (Telemetry.Activities.StartMethod<AssetQueryService>())
+            using (Telemetry.Activities.StartActivity("AssetQueryService/FindAsync"))
            {
                IAssetEntity? asset;

@ -180,7 +180,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
                return EmptyAssets;
            }

-            using (Telemetry.Activities.StartMethod<AssetQueryService>())
+            using (Telemetry.Activities.StartActivity("AssetQueryService/QueryAsync"))
            {
                q = await queryParser.ParseAsync(context, q);

@ -214,7 +214,7 @@ namespace Squidex.Domain.Apps.Entities.Assets.Queries
        private async Task<IReadOnlyList<IEnrichedAssetEntity>> TransformCoreAsync(Context context, IEnumerable<IAssetEntity> assets,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<AssetQueryService>())
+            using (Telemetry.Activities.StartActivity("AssetQueryService/TransformCoreAsync"))
            {
                return await assetEnricher.EnrichAsync(assets, context, ct);
            }
--- a/backend/src/Squidex.Domain.Apps.Entities/Backup/RestoreGrain.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Backup/RestoreGrain.cs
@ -163,7 +163,7 @@ namespace Squidex.Domain.Apps.Entities.Backup

                        foreach (var handler in handlers)
                        {
-                            using (Telemetry.Activities.StartMethod(handler.GetType(), nameof(IBackupHandler.RestoreAsync)))
+                            using (Telemetry.Activities.StartActivity($"{handler.GetType().Name}/RestoreAsync"))
                            {
                                await handler.RestoreAsync(runningContext);
                            }
@ -173,7 +173,7 @@ namespace Squidex.Domain.Apps.Entities.Backup

                        foreach (var handler in handlers)
                        {
-                            using (Telemetry.Activities.StartMethod(handler.GetType(), nameof(IBackupHandler.CompleteRestoreAsync)))
+                            using (Telemetry.Activities.StartActivity($"{handler.GetType().Name}/CompleteRestoreAsync"))
                            {
                                await handler.CompleteRestoreAsync(runningContext);
                            }
--- a/backend/src/Squidex.Domain.Apps.Entities/Contents/DomainObject/Guards/SecurityExtensions.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Contents/DomainObject/Guards/SecurityExtensions.cs
@ -6,7 +6,6 @@
 // ==========================================================================

 using Squidex.Infrastructure;
-using Squidex.Infrastructure.Security;
 using Squidex.Infrastructure.Translations;
 using Squidex.Shared;
 using Squidex.Shared.Identity;
--- a/backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/ContentEnricher.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/ContentEnricher.cs
@ -50,7 +50,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
        private async Task<IReadOnlyList<IEnrichedContentEntity>> EnrichInternalAsync(IEnumerable<IContentEntity> contents, bool cloneData, Context context,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<ContentEnricher>())
+            using (Telemetry.Activities.StartActivity("ContentEnricher/EnrichInternalAsync"))
            {
                var results = new List<ContentEntity>();

@ -101,7 +101,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
                        {
                            ct.ThrowIfCancellationRequested();

-                            using (Telemetry.Activities.StartMethod(step.ToString()!))
+                            using (Telemetry.Activities.StartActivity(step.ToString()!))
                            {
                                await step.EnrichAsync(context, results, GetSchema, ct);
                            }
--- a/backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/ContentLoader.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/ContentLoader.cs
@ -23,7 +23,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries

        public async Task<IContentEntity?> GetAsync(DomainId appId, DomainId id, long version)
        {
-            using (Telemetry.Activities.StartMethod<ContentLoader>())
+            using (Telemetry.Activities.StartActivity("ContentLoader/GetAsync"))
            {
                var key = DomainId.Combine(appId, id).ToString();

--- a/backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/ContentQueryParser.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/ContentQueryParser.cs
@ -58,7 +58,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
            Guard.NotNull(context, nameof(context));
            Guard.NotNull(q, nameof(q));

-            using (Telemetry.Activities.StartMethod<ContentQueryParser>())
+            using (Telemetry.Activities.StartActivity("ContentQueryParser/ParseAsync"))
            {
                var query = await ParseClrQueryAsync(context, q, schema);

--- a/backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/ContentQueryService.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Contents/Queries/ContentQueryService.cs
@ -17,7 +17,6 @@ using Squidex.Infrastructure;
 using Squidex.Infrastructure.Security;
 using Squidex.Infrastructure.Translations;
 using Squidex.Shared;
-using Squidex.Shared.Identity;

 namespace Squidex.Domain.Apps.Entities.Contents.Queries
 {
@ -53,7 +52,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
        {
            Guard.NotNull(context, nameof(context));

-            using (Telemetry.Activities.StartMethod<ContentQueryService>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/FindAsync"))
            {
                var schema = await GetSchemaOrThrowAsync(context, schemaIdOrName);

@ -87,7 +86,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
        {
            Guard.NotNull(context, nameof(context));

-            using (Telemetry.Activities.StartMethod<ContentQueryService>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/QueryAsync"))
            {
                if (q == null)
                {
@ -119,7 +118,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
        {
            Guard.NotNull(context, nameof(context));

-            using (Telemetry.Activities.StartMethod<ContentQueryService>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/QueryAsync"))
            {
                if (q == null)
                {
@ -165,7 +164,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.Queries
        private async Task<IReadOnlyList<IEnrichedContentEntity>> TransformCoreAsync(Context context, IEnumerable<IContentEntity> contents,
            CancellationToken ct)
        {
-            using (Telemetry.Activities.StartMethod<ContentQueryService>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/TransformCoreAsync"))
            {
                return await contentEnricher.EnrichAsync(contents, context, ct);
            }
--- a/backend/src/Squidex.Domain.Apps.Entities/Rules/Indexes/RulesIndex.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Rules/Indexes/RulesIndex.cs
@ -32,7 +32,7 @@ namespace Squidex.Domain.Apps.Entities.Rules.Indexes

        public async Task<List<IRuleEntity>> GetRulesAsync(DomainId appId)
        {
-            using (Telemetry.Activities.StartMethod<RulesIndex>())
+            using (Telemetry.Activities.StartActivity("RulesIndex/GetRulesAsync"))
            {
                var ids = await GetRuleIdsAsync(appId);

@ -46,7 +46,7 @@ namespace Squidex.Domain.Apps.Entities.Rules.Indexes

        private async Task<List<DomainId>> GetRuleIdsAsync(DomainId appId)
        {
-            using (Telemetry.Activities.StartMethod<RulesIndex>())
+            using (Telemetry.Activities.StartActivity("RulesIndex/GetRuleIdsAsync"))
            {
                return await Index(appId).GetIdsAsync();
            }
--- a/backend/src/Squidex.Domain.Apps.Entities/Rules/Queries/RuleEnricher.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Rules/Queries/RuleEnricher.cs
@ -41,7 +41,7 @@ namespace Squidex.Domain.Apps.Entities.Rules.Queries
            Guard.NotNull(rules, nameof(rules));
            Guard.NotNull(context, nameof(context));

-            using (Telemetry.Activities.StartMethod<RuleEnricher>())
+            using (Telemetry.Activities.StartActivity("RuleEnricher/EnrichAsync"))
            {
                var results = new List<RuleEntity>();

--- a/backend/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasIndex.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasIndex.cs
@ -1,4 +1,4 @@
-// ==========================================================================
+// ==========================================================================
 //  Squidex Headless CMS
 // ==========================================================================
 //  Copyright (c) Squidex UG (haftungsbeschraenkt)
@ -40,7 +40,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes

        public async Task<List<ISchemaEntity>> GetSchemasAsync(DomainId appId)
        {
-            using (Telemetry.Activities.StartMethod<SchemasIndex>())
+            using (Telemetry.Activities.StartActivity("SchemasIndex/GetSchemasAsync"))
            {
                var ids = await GetSchemaIdsAsync(appId);

@ -54,7 +54,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes

        public async Task<ISchemaEntity?> GetSchemaByNameAsync(DomainId appId, string name, bool canCache)
        {
-            using (Telemetry.Activities.StartMethod<SchemasIndex>())
+            using (Telemetry.Activities.StartActivity("SchemasIndex/GetSchemaByNameAsync"))
            {
                var cacheKey = GetCacheKey(appId, name);

@ -79,7 +79,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes

        public async Task<ISchemaEntity?> GetSchemaAsync(DomainId appId, DomainId id, bool canCache)
        {
-            using (Telemetry.Activities.StartMethod<SchemasIndex>())
+            using (Telemetry.Activities.StartActivity("SchemasIndex/GetSchemaAsync"))
            {
                var cacheKey = GetCacheKey(appId, id);

@ -104,7 +104,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes

        private async Task<DomainId> GetSchemaIdAsync(DomainId appId, string name)
        {
-            using (Telemetry.Activities.StartMethod<SchemasIndex>())
+            using (Telemetry.Activities.StartActivity("SchemasIndex/GetSchemaIdAsync"))
            {
                return await Index(appId).GetIdAsync(name);
            }
@ -112,7 +112,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes

        private async Task<List<DomainId>> GetSchemaIdsAsync(DomainId appId)
        {
-            using (Telemetry.Activities.StartMethod<SchemasIndex>())
+            using (Telemetry.Activities.StartActivity("SchemasIndex/GetSchemaIdsAsync"))
            {
                return await Index(appId).GetIdsAsync();
            }
--- a/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEventStore_Reader.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEventStore_Reader.cs
@ -47,7 +47,7 @@ namespace Squidex.Infrastructure.EventSourcing
                return EmptyEvents;
            }

-            using (Telemetry.Activities.StartMethod<MongoEventStore>())
+            using (Telemetry.Activities.StartActivity("MongoEventStore/QueryLatestAsync"))
            {
                var commits =
                    await Collection.Find(
@ -64,7 +64,7 @@ namespace Squidex.Infrastructure.EventSourcing
        {
            Guard.NotNullOrEmpty(streamName, nameof(streamName));

-            using (Telemetry.Activities.StartMethod<MongoEventStore>())
+            using (Telemetry.Activities.StartActivity("MongoEventStore/QueryAsync"))
            {
                var commits =
                    await Collection.Find(
@ -83,7 +83,7 @@ namespace Squidex.Infrastructure.EventSourcing
        {
            Guard.NotNull(streamNames, nameof(streamNames));

-            using (Telemetry.Activities.StartMethod<MongoEventStore>())
+            using (Telemetry.Activities.StartActivity("MongoEventStore/QueryManyAsync"))
            {
                var position = EtagVersion.Empty;

--- a/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEventStore_Writer.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEventStore_Writer.cs
@ -39,7 +39,7 @@ namespace Squidex.Infrastructure.EventSourcing
            Guard.LessThan(events.Count, MaxCommitSize, "events.Count");
            Guard.GreaterEquals(expectedVersion, EtagVersion.Any, nameof(expectedVersion));

-            using (Telemetry.Activities.StartMethod<MongoEventStore>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/AppendAsync"))
            {
                if (events.Count == 0)
                {
@ -101,7 +101,7 @@ namespace Squidex.Infrastructure.EventSourcing
        {
            Guard.NotNull(commits, nameof(commits));

-            using (Telemetry.Activities.StartMethod<MongoEventStore>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/AppendUnsafeAsync"))
            {
                var writes = new List<WriteModel<MongoEventCommit>>();

@ -163,4 +163,4 @@ namespace Squidex.Infrastructure.EventSourcing
            return mongoCommit;
        }
    }
-}
+}
--- a/backend/src/Squidex.Infrastructure.MongoDb/States/MongoSnapshotStore.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/States/MongoSnapshotStore.cs
@ -44,7 +44,7 @@ namespace Squidex.Infrastructure.States

        public async Task<(T Value, bool Valid, long Version)> ReadAsync(DomainId key)
        {
-            using (Telemetry.Activities.StartMethod<MongoSnapshotStore<T>>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/ReadAsync"))
            {
                var existing =
                    await Collection.Find(x => x.DocumentId.Equals(key))
@ -61,7 +61,7 @@ namespace Squidex.Infrastructure.States

        public async Task WriteAsync(DomainId key, T value, long oldVersion, long newVersion)
        {
-            using (Telemetry.Activities.StartMethod<MongoSnapshotStore<T>>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/WriteAsync"))
            {
                await Collection.UpsertVersionedAsync(key, oldVersion, newVersion, u => u.Set(x => x.Doc, value));
            }
@ -69,7 +69,7 @@ namespace Squidex.Infrastructure.States

        public Task WriteManyAsync(IEnumerable<(DomainId Key, T Value, long Version)> snapshots)
        {
-            using (Telemetry.Activities.StartMethod<MongoSnapshotStore<T>>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/WriteManyAsync"))
            {
                var writes = snapshots.Select(x => new ReplaceOneModel<MongoState<T>>(
                    Filter.Eq(y => y.DocumentId, x.Key),
@ -95,7 +95,7 @@ namespace Squidex.Infrastructure.States
        public async Task ReadAllAsync(Func<T, long, Task> callback,
            CancellationToken ct = default)
        {
-            using (Telemetry.Activities.StartMethod<MongoSnapshotStore<T>>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/ReadAllAsync"))
            {
                await Collection.Find(new BsonDocument(), options: Batching.Options).ForEachAsync(x => callback(x.Doc, x.Version), ct);
            }
@ -103,7 +103,7 @@ namespace Squidex.Infrastructure.States

        public async Task RemoveAsync(DomainId key)
        {
-            using (Telemetry.Activities.StartMethod<MongoSnapshotStore<T>>())
+            using (Telemetry.Activities.StartActivity("ContentQueryService/RemoveAsync"))
            {
                await Collection.DeleteOneAsync(x => x.DocumentId.Equals(key));
            }
--- a/backend/src/Squidex.Infrastructure/Orleans/J{T}.cs
+++ b/backend/src/Squidex.Infrastructure/Orleans/J{T}.cs
@ -56,7 +56,7 @@ namespace Squidex.Infrastructure.Orleans
        [SerializerMethod]
        public static void Serialize(object? input, ISerializationContext context, Type? expected)
        {
-            using (Telemetry.Activities.StartMethod(nameof(J)))
+            using (Telemetry.Activities.StartActivity("JsonSerializer/Serialize"))
            {
                var jsonSerializer = GetSerializer(context);

@ -69,7 +69,7 @@ namespace Squidex.Infrastructure.Orleans
        [DeserializerMethod]
        public static object? Deserialize(Type expected, IDeserializationContext context)
        {
-            using (Telemetry.Activities.StartMethod(nameof(J)))
+            using (Telemetry.Activities.StartActivity("JsonSerializer/Deserialize"))
            {
                var jsonSerializer = GetSerializer(context);

--- a/backend/src/Squidex.Infrastructure/Telemetry.cs
+++ b/backend/src/Squidex.Infrastructure/Telemetry.cs
@ -5,9 +5,7 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================

-using System;
 using System.Diagnostics;
-using System.Runtime.CompilerServices;

 namespace Squidex.Infrastructure
 {
@ -15,34 +13,14 @@ namespace Squidex.Infrastructure
    {
        public static readonly ActivitySource Activities = new ActivitySource("Squidex");

-        public static Activity? StartMethod(this ActivitySource activity, Type type, [CallerMemberName] string? memberName = null)
+        public static Activity? StartSubActivity(this ActivitySource activity, string name)
        {
            if (Activity.Current == null)
            {
                return null;
            }

-            return activity.StartActivity($"{type.Name}/{memberName}");
-        }
-
-        public static Activity? StartMethod<T>(this ActivitySource activity, [CallerMemberName] string? memberName = null)
-        {
-            if (Activity.Current == null)
-            {
-                return null;
-            }
-
-            return activity.StartActivity($"{typeof(T).Name}/{memberName}");
-        }
-
-        public static Activity? StartMethod(this ActivitySource activity, string objectName, [CallerMemberName] string? memberName = null)
-        {
-            if (Activity.Current == null)
-            {
-                return null;
-            }
-
-            return activity.StartActivity($"{objectName}/{memberName}");
+            return activity.StartActivity(name);
        }
    }
 }
--- a/backend/src/Squidex.Web/ETagExtensions.cs
+++ b/backend/src/Squidex.Web/ETagExtensions.cs
@ -11,7 +11,6 @@ using System.Security.Cryptography;
 using System.Text;
 using Squidex.Domain.Apps.Entities;
 using Squidex.Infrastructure;
-using Squidex.Log;

 namespace Squidex.Web
 {
--- a/backend/src/Squidex.Web/Pipeline/ApiCostsFilter.cs
+++ b/backend/src/Squidex.Web/Pipeline/ApiCostsFilter.cs
@ -12,7 +12,6 @@ using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Filters;
 using Squidex.Domain.Apps.Entities.Apps.Plans;
 using Squidex.Infrastructure;
-using Squidex.Log;

 namespace Squidex.Web.Pipeline
 {
--- a/backend/src/Squidex.Web/Pipeline/CachingManager.cs
+++ b/backend/src/Squidex.Web/Pipeline/CachingManager.cs
@ -18,7 +18,6 @@ using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Caching;
-using Squidex.Log;

 namespace Squidex.Web.Pipeline
 {
--- a/backend/src/Squidex/Areas/Api/Controllers/Assets/AssetContentController.cs
+++ b/backend/src/Squidex/Areas/Api/Controllers/Assets/AssetContentController.cs
@ -20,7 +20,6 @@ using Squidex.Domain.Apps.Entities;
 using Squidex.Domain.Apps.Entities.Assets;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Commands;
-using Squidex.Log;
 using Squidex.Web;

 #pragma warning disable CA2016 // Forward the 'CancellationToken' parameter to methods that take one
--- a/helm/index.yaml
+++ b/helm/index.yaml
@ -3,14 +3,14 @@ entries:
  squidex:
  - apiVersion: v2
    appVersion: 5.8.0
-    created: "2021-08-27T10:25:24.213478+02:00"
+    created: "2021-09-13T13:02:07.445459+02:00"
    dependencies:
    - condition: mongodb-replicaset.enabled
      name: mongodb-replicaset
      repository: https://kubernetes-charts.storage.googleapis.com/
      version: 3.9.6
    description: Squidex CMS
-    digest: 5361ff43139714e97147eb1e667d2c64bddbec23511b8bed1f264bf2e9758d07
+    digest: 4837131004d23a1de21eb6d8d8576e6fadad990a49136af061d2c7e43bbaff9d
    home: https://squidex.io/
    keywords:
    - cms
@ -26,4 +26,4 @@ entries:
    urls:
    - https://squidex.github.io/squidex/helm/squidex-1.0.0.tgz
    version: 1.0.0
-generated: "2021-08-27T10:25:24.208859+02:00"
+generated: "2021-09-13T13:02:07.441734+02:00"
--- a/helm/squidex-1.0.0.tgz
+++ b/helm/squidex-1.0.0.tgz