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

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);
 

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);
             }

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)

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);
             }

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);
             }

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>();

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);
             }

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();
 

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);
 

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);
 

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);
             }

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);
                             }

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;

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);
                             }

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();
 

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);
 

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);
             }

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();
             }

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>();
 

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();
             }

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;
 

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>>();
 

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));
             }

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);
 

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}");
+            return activity.StartActivity(name);
-        }
-
-        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}");
         }
     }
 }

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
 {

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
 {

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
 {

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

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"