{"title":"Analyze and monitor telemetry with KQL","url":"https://jonas-paprotka.de/docs/dev-itpro/administration/telemetry-analyze-with-kql/","by":"JOP-AL","license":"Copyright (c) Microsoft Corporation. CC BY 4.0, https://creativecommons.org/licenses/by/4.0/; code samples MIT. From https://learn.microsoft.com/en-us/dynamics365/business-central/dev-itpro/administration/telemetry-analyze-with-kql, MicrosoftDocs/dynamics365smb-devitpro-pb at 828b6ee (2026-11-19). Changed: includes filled in, links to this site, and for agents shortened without dropping a fact.","credit":"Microsoft Corporation, CC BY 4.0","origin":"https://learn.microsoft.com/en-us/dynamics365/business-central/dev-itpro/administration/telemetry-analyze-with-kql","source":{"name":"Business Central developer and IT pro docs","repo":"https://github.com/MicrosoftDocs/dynamics365smb-devitpro-pb","commit":"828b6ee72fcd75755627cd6011f3d20899217ab2","date":"2026-11-19"},"checked":"2026-11-19","description":"Query Business Central telemetry with Kusto Query Language to follow sessions and users, investigate performance, and analyze report usage.","date":"2026-11-17","meta":{"topic":"overview"},"outline":[{"level":1,"title":"Analyze and monitor telemetry with KQL","slug":"analyze-and-monitor-telemetry-with-kql","at":0,"chars":25154},{"level":2,"title":"Where can I use Kusto queries?","slug":"where-can-i-use-kusto-queries","at":902,"chars":260},{"level":2,"title":"Where can I learn more about KQL?","slug":"where-can-i-learn-more-about-kql","at":1162,"chars":174},{"level":2,"title":"Which tools can I use (KQL editors and clients)?","slug":"which-tools-can-i-use-kql-editors-and-clients","at":1336,"chars":251},{"level":2,"title":"How can I query telemetry from Log Analytics?","slug":"how-can-i-query-telemetry-from-log-analytics","at":1587,"chars":729},{"level":2,"title":"KQL example - dealing with timezones","slug":"kql-example---dealing-with-timezones","at":2316,"chars":703},{"level":2,"title":"KQL example - finding the start time of an event","slug":"kql-example---finding-the-start-time-of-an-event","at":3019,"chars":888},{"level":2,"title":"KQL example - following telemetry events for a session","slug":"kql-example---following-telemetry-events-for-a-session","at":3907,"chars":919},{"level":2,"title":"KQL example - following telemetry events for a user","slug":"kql-example---following-telemetry-events-for-a-user","at":4826,"chars":998},{"level":2,"title":"KQL walkthrough example - understand report usage","slug":"kql-walkthrough-example---understand-report-usage","at":5824,"chars":19131},{"level":3,"title":"About this walkthrough","slug":"about-this-walkthrough","at":6430,"chars":856},{"level":3,"title":"Prerequisites","slug":"prerequisites","at":7286,"chars":437},{"level":3,"title":"Understand report usage with telemetry and KQL","slug":"understand-report-usage-with-telemetry-and-kql","at":7723,"chars":17232},{"level":2,"title":"Related information","slug":"related-information","at":24955,"chars":199}],"text":"# Analyze and monitor telemetry with KQL\nTelemetry from Business Central is stored in Azure Application Insights in the tables traces and pageViews. The language used to query data in Azure Application Insights is _Kusto Query Language_ (KQL). This article has information and links to resources to get started learning about the KQL language.\nAs a simple example, follow these steps:\n1. In the Azure portal, open your Application Insights resource.\n1. In the Monitoring menu, select Logs.\n1. On the New Query tab, enter the following to get the last 100 traces:\n ```kql\n traces\n | where timestamp > ago(7d)                     // look back 7 days\n | top 100 by timestamp desc                     // get the most recent 100 rows\n | project timestamp, message, customDimensions  // only choose these three columns\n | sort by timestamp desc                        // show the most recent data first\n ```\n## Where can I use Kusto queries?\nYou can use Kusto queries as the data source in many places. For example:\n The logs part of Application Insights in the Azure portal\n Power BI reports\n Alerts\n Azure Dashboards\n Jupyter Notebooks (with the Kqlmagic extension)\n## Where can I learn more about KQL?\nGo to Kusto Query Language (KQL)<https://learn.microsoft.com/azure/data-explorer/kusto/query/> in the Azure Data Explorer documentation.\n## Which tools can I use (KQL editors and clients)?\nTo get an overview of the different tools, go to https://learn.microsoft.com/azure/data-explorer/tools-integrations-overview#azure-data-explorer-query-tools in the Azure Data Explorer documentation.\n## How can I query telemetry from Log Analytics?\nWith workspace-based resources, Azure Application Insights sends telemetry to a common Azure Log Analytics workspace, providing full access to all the features of Azure Log Analytics while keeping your application, infrastructure, and platform logs in a single consolidated location. This integration allows for common Azure role-based access control across your resources and eliminates the need for cross-app/workspace queries.\nThis table shows table names for Business Central telemetry when queried from Azure Application Insights and from Azure Log Analytics:\nTable name in Azure Application Insights|Table name in Azure Log Analytics\ntraces|AppTraces\npageViews|AppPageViews\n## KQL example - dealing with timezones\nAll telemetry events have a timestamp column that contains the time for which the event was emitted. The Business Central server always emits the timestamp in UTC timezone. In case your environment is located in a different timezone, you can use a Kusto function to convert timestamps to reflect that.\nUse this KQL code to convert timestamps to another timezone:\n```kql\ntraces\n| where timestamp > ago(30d) // adjust as needed\n// more where clauses here ...\n| extend timestamp_in_local_timezone = datetime_utc_to_local(timestamp, 'America/North_Dakota/Center')\n// project clause here\n```\nSee https://learn.microsoft.com/kusto/query/datetime-utc-to-local-function.\n## KQL example - finding the start time of an event\nAll telemetry events have a timestamp column that contains the time for which the event was emitted. But for events such as report execution, database lock timeouts, long running SQL query, or long running AL operation, the start time of the event is likely different from this timestamp. Fortunately, for many event types, you have a way to compute the start time.\nUse this KQL code to query the start time for a long running event:\n```kql\n// Long running SQL queries (get start time for events)\ntraces\n| where timestamp > ago(30d) // adjust as needed\n| where customDimensions.eventId == 'RT0005'\n| extend executionTime = totimespan(customDimensions.executionTime)\n| extend executionTimeInMS = executionTime / 1ms\n| project start_time = timestamp - executionTime\n, executionTimeInMS\n, end_time=timestamp\n// add more data as needed\n```\n## KQL example - following telemetry events for a session\nIn Business Central version 24 and later, the server and the browser components align on the globally unique identifiers (GUIDs) logged to the session_Id column in the traces and pageViews tables. This behavior allows you to do advanced troubleshooting such as following what happens within a session.\nUse this KQL code to query what happens in a single session:\n```kql\nlet _session_Id = 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb' // change to the guid for the session you want to follow\n;\nlet pv =\npageViews\n| where session_Id == _session_Id\n| extend message = strcat('Page opened: ', name)\n| project timestamp, session_Id, user_Id, message, clientType='WebClient'\n;\nlet tra =\ntraces\n| where session_Id == _session_Id\n| project timestamp, session_Id, user_Id, message, clientType= tostring(customDimensions.clientType)\n;\nunion pv, tra\n| order by timestamp asc\n```\n## KQL example - following telemetry events for a user\nIn Business Central version 24 and later, the server and the browser components align on the GUIDs logged to the user_Id column in the traces and pageViews tables. This behavior allows you to do advanced troubleshooting such as following what a user does. To see which user corresponds to the guid logged in the user_Id column, see telemetry-enable-application-insights#assign-a-telemetry-id-to-users.\nUse this KQL code to query what a user does across sessions:\n```kql\nlet _user_Id = '00aa00aa-bb11-cc22-dd33-44ee44ee44ee' // change to the guid for the user you want to follow\n;\nlet pv =\npageViews\n| where user_Id == _user_Id\n| extend message = strcat('Page opened: ', name)\n| project timestamp, session_Id, user_Id, message, clientType='WebClient'\n;\nlet tra =\ntraces\n| where user_Id == _user_Id\n| project timestamp, session_Id, user_Id, message, clientType= tostring(customDimensions.clientType)\n;\nunion pv, tra\n| order by timestamp asc\n```\n## KQL walkthrough example - understand report usage\nThis walkthrough guides you to create a Kusto (KQL) query to analyze how users use reports in a Business Central environment. You start with a sample query from the documentation article for report telemetry. Then, you change and refine the query step by step, learning about important KQL operators along the way. The final result shows you data for the most frequently used reports. The reports are grouped by the app/extension they're from, what users did with the report (download/preview/print/...), and the layout (Excel/Word/RDLC) that was used.\n### About this walkthrough\nThis walkthrough covers the following tasks:\n1. Choose a query tool for KQL, either the Logs part of the Monitoring menu in Application Insights in the Azure portal, or in Kusto. Explorer (see Kusto.Explorer installation and user interface<https://learn.microsoft.com/azure/data-explorer/kusto/tools/kusto-explorer>).\n2. Get a sample query (in this example, we use the sample query for report renderings).\n3. Limit the result rows by adding a take operator.\n4. Limit the result columns by removing lines from the project operator.\n5. Add a summarize operator and learn gotchas about the dynamic datatype customDimensions.\n6. Add group by parts to the summarize operator.\n7. Rename columns in the result.\n8. Add an `order by` to see the most frequent reports first.\n9. Add a take operator to get the top 10 most frequent reports.\n### Prerequisites\nTo complete this walkthrough, you need:\n An Azure Application Insights resource.\n Report telemetry from Business Central emitted to Application Insights.\n A query tool for KQL, either the Logs part of the Monitoring menu in Application Insights in the Azure portal, or the Kusto. Explorer (see Kusto.Explorer installation and user interface<https://learn.microsoft.com/azure/data-explorer/kusto/tools/kusto-explorer>).\n### Understand report usage with telemetry and KQL\nFirst, go to the article on report telemetry Analyzing Report Telemetry<telemetry-reports-trace#sample-kql-code-successful-report-generation---all-dimensions>\nNow, copy the KQL query for successful report generation:\nThis KQL code can help you get started analyzing report rendering:\n```kql\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where customDimensions has 'RT0006'\n| where customDimensions.eventId == 'RT0006'\n// | where operation_Name == \"Success report generation\" // use this instead of eventId clause for versions 16.0 or earlier\n| where customDimensions.result == \"Success\"\n| project timestamp\n// in which environment/company did it happen\n, aadTenantId = customDimensions.aadTenantId\n, environmentName = customDimensions.environmentName\n, environmentType = customDimensions.environmentType\n, companyName = customDimensions.companyName\n// in which extension/app\n, extensionId = customDimensions.extensionId\n, extensionName = customDimensions.extensionName\n, extensionVersion = customDimensions.extensionVersion\n, extensionPublisher = customDimensions.extensionPublisher\n// in which object\n, alObjectId = customDimensions.alObjectId\n, alObjectName = customDimensions.alObjectName\n, alObjectType = customDimensions.alObjectType\n// what did the user do\n, documentFormat = customDimensions.documentFormat   // documentFormat dimension added in version 20.0\n, LayoutAppId = customDimensions.layoutAppId         // layout dimensions added in version 20.0\n, LayoutName = customDimensions.layoutName           // layout dimensions added in version 20.0\n, LayoutType = customDimensions.layoutType           // layout dimensions added in version 20.0\n, ThemeLayoutAppId = customDimensions.themeLayoutAppId                 // added in version 29.0\n, ThemeLayoutName = customDimensions.themeLayoutName                   // added in version 29.0\n, HeaderFooterLayoutAppId = customDimensions.headerFooterLayoutAppId   // added in version 29.0\n, HeaderFooterLayoutName = customDimensions.headerFooterLayoutName     // added in version 29.0\n, reportAction = customDimensions.reportAction       // reportAction dimension added in version 20.0\n, reportingEngine = customDimensions.reportingEngine // reportingEngine dimension was added in version 17.3\n// which user ran the report\n, usertelemetryId = case(\n  toint( substring(customDimensions.componentVersion,0,2)) >= 20, user_Id // user telemetry ID was introduced in the platform in version 20.0\n, 'N/A'\n)\n// performance data\n, numberOfDocuments = customDimensions.numberOfDocuments\n, numberOfRows = customDimensions.numberOfRows\n// , serverExecutionTime = customDimensions.serverExecutionTime // the datatype for executionTime is timespan\n, serverExecutionTimeInMS = toreal(totimespan(customDimensions.serverExecutionTime))/10000 // this shows how to convert timespan to milliseconds\n, sqlDatabaseAccessIntent = customDimensions.sqlDatabaseAccessIntent  // sqlDatabaseAccessIntent dimension added in version 19.1\n, sqlExecutes = customDimensions.sqlExecutes\n, sqlRowsRead = customDimensions.sqlRowsRead\n// , totalTime = customDimensions.totalTime // the datatype for totalTime is timespan\n, totalTimeInMS = toreal(totimespan(customDimensions.totalTime))/10000 // this shows how to convert timespan to milliseconds\n| extend renderTimeInMS = totalTimeInMS - serverExecutionTimeInMS\n```\nThe query in the previous paragraph has four parts: a table and three KQL operators separated by a pipe (`|`):\n1. Which Kusto table that stores the data\n2. where operators to filter the data\n3. a project operator limits the number of columns\n4. an extend operator to add new columns (calculations)\n```kql\ntraces // which kusto table that stores the data\n// where operators filter the data\n| where timestamp > ago(60d) // adjust as needed\n| where operation_Name == \"Success report generation\" // do note that in a later version of the schema, this field will not be used\n     or customDimensions.eventId == 'RT0006' // introduced in version 16.1\n| where customDimensions.result == \"Success\"\n//\n// the project operator limits the number of columns\n| project timestamp\n, aadTenantId = customDimensions.aadTenantId\n// ...\n// ...\n// the extend operator can be used to add new columns (calculations)\n| extend renderTimeInMS = totalTimeInMS - serverExecutionTimeInMS\n```\nWhen writing KQL queries, it's good practice to limit the number of rows while developing it. This practice allows for quick explorations and experimentation without having to wait for the result in each modification of the query.\nSo, before running the query, add a take operator on a new line after the where operators and before the project operator:\nYour query should now look like this:\n```kql\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where operation_Name == 'Success report generation' // do note that in a later version of the schema, this field will not be used\n     or customDimensions.eventId == 'RT0006'          // introduced in version 16.1\n| where customDimensions.result == 'Success'\n| take 5\n| project timestamp\n// in which environment/company did it happen\n, aadTenantId = customDimensions.aadTenantId\n, environmentName = customDimensions.environmentName\n, environmentType = customDimensions.environmentType\n, companyName = customDimensions.companyName\n// in which extension/app\n, extensionId = customDimensions.extensionId\n, extensionName = customDimensions.extensionName\n, extensionVersion = customDimensions.extensionVersion\n, extensionPublisher = customDimensions.extensionPublisher\n// in which object\n, alObjectId = customDimensions.alObjectId\n, alObjectName = customDimensions.alObjectName\n, alObjectType = customDimensions.alObjectType\n// what did the user do\n, documentFormat = customDimensions.documentFormat   // documentFormat dimension added in version 20.0\n, LayoutAppId = customDimensions.layoutAppId         // layout dimensions added in version 20.0\n, LayoutName = customDimensions.layoutName           // layout dimensions added in version 20.0\n, LayoutType = customDimensions.layoutType           // layout dimensions added in version 20.0\n, reportAction = customDimensions.reportAction       // reportAction dimension added in version 20.0\n, reportingEngine = customDimensions.reportingEngine // reportingEngine dimension was added in version 17.3\n// which user ran the report\n, usertelemetryId = case(\n  toint( substring(customDimensions.componentVersion,0,2)) >= 20, user_Id // user telemetry id was introduced in the platform in version 20.0\n, 'N/A'\n)\n// performance data\n, numberOfRows = customDimensions.numberOfRows\n// , serverExecutionTime = customDimensions.serverExecutionTime // the datatype for executionTime is timespan\n, serverExecutionTimeInMS = totimespan(customDimensions.serverExecutionTime) / 1ms // convert timespan to milliseconds\n, sqlDatabaseAccessIntent = customDimensions.sqlDatabaseAccessIntent  // sqlDatabaseAccessIntent dimension added in version 19.1\n, sqlExecutes = customDimensions.sqlExecutes\n, sqlRowsRead = customDimensions.sqlRowsRead\n// , totalTime = customDimensions.totalTime // the datatype for totalTime is timespan\n, totalTimeInMS = totimespan(customDimensions.totalTime) / 1ms // convert timespan to milliseconds\n| extend renderTimeInMS = totalTimeInMS - serverExecutionTimeInMS\n```\nTry running the query. You should now see five rows with numerous columns.\nAs you can see on the result, the original query includes many columns. In this example, we aren't interested in performance data and other details. So, we remove the lines that we don't need from the project part of the query:\n```kql\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where operation_Name == 'Success report generation' // do note that in a later version of the schema, this field will not be used\n     or customDimensions.eventId == 'RT0006'          // introduced in version 16.1\n| where customDimensions.result == 'Success'\n| take 5\n| project timestamp\n// in which environment/company did it happen\n, aadTenantId = customDimensions.aadTenantId\n, environmentName = customDimensions.environmentName\n, environmentType = customDimensions.environmentType\n// in which extension/app\n, extensionId = customDimensions.extensionId\n, extensionName = customDimensions.extensionName\n, extensionVersion = customDimensions.extensionVersion\n, extensionPublisher = customDimensions.extensionPublisher\n// in which object\n, alObjectId = customDimensions.alObjectId\n, alObjectName = customDimensions.alObjectName\n, LayoutType = customDimensions.layoutType           // layout dimensions added in version 20.0\n, reportAction = customDimensions.reportAction       // reportAction dimension added in version 20.0\n```\nTry running the query again. You should now see five rows with a lot fewer columns.\nNext, we want to summarize how many reports ran. So, we add a new line with a summarize operator to the query:\n```kql\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where operation_Name == 'Success report generation' // do note that in a later version of the schema, this field will not be used\n     or customDimensions.eventId == 'RT0006'          // introduced in version 16.1\n| where customDimensions.result == 'Success'\n| take 5\n| project timestamp\n// in which environment/company did it happen\n, aadTenantId = customDimensions.aadTenantId\n, environmentName = customDimensions.environmentName\n, environmentType = customDimensions.environmentType\n// in which extension/app\n, extensionId = customDimensions.extensionId\n, extensionName = customDimensions.extensionName\n, extensionVersion = customDimensions.extensionVersion\n, extensionPublisher = customDimensions.extensionPublisher\n// in which object\n, alObjectId = customDimensions.alObjectId\n, alObjectName = customDimensions.alObjectName\n, LayoutType = customDimensions.layoutType           // layout dimensions added in version 20.0\n, reportAction = customDimensions.reportAction       // reportAction dimension added in version 20.0\n| summarize count()\n```\nThis query shows you a total count of all reports that were run. Because you have a `take 5` in there, the count is also five. Now, change that limit to 100 as we're ready to group by some columns:\n```kql\n// Note that this query will fail with the error\n//\n// Summarize group key 'alObjectName' is of a 'dynamic' type. Please use an explicit cast (for example, 'summarize ... by tostring(alObjectName)') as grouping by a 'dynamic' type is not supported.\n//\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where operation_Name == 'Success report generation' // do note that in a later version of the schema, this field will not be used\n     or customDimensions.eventId == 'RT0006'          // introduced in version 16.1\n| where customDimensions.result == 'Success'\n| take 100\n| project timestamp\n// in which environment/company did it happen\n, aadTenantId = customDimensions.aadTenantId\n, environmentName = customDimensions.environmentName\n, environmentType = customDimensions.environmentType\n// in which extension/app\n, extensionId = customDimensions.extensionId\n, extensionName = customDimensions.extensionName\n, extensionVersion = customDimensions.extensionVersion\n, extensionPublisher = customDimensions.extensionPublisher\n// in which object\n, alObjectId = customDimensions.alObjectId\n, alObjectName = customDimensions.alObjectName\n, LayoutType = customDimensions.layoutType           // layout dimensions added in version 20.0\n, reportAction = customDimensions.reportAction       // reportAction dimension added in version 20.0\n| summarize count() by alObjectName\n```\nAll of the context for the report rendering (which object ID/name, extension/app details etc.) is stored in a data structure called customDimensions. For such columns to work in the by part of the summarize operator, they must be converted to strings or numbers, otherwise you get this error when running the query:\n> Summarize group key 'alObjectName' is of a 'dynamic' type. Please use an explicit cast (for example, 'summarize ... by tostring(alObjectName)') as grouping by a 'dynamic' type is not supported.\nLet's quickly fix that and add a tostring command to the by part of the summarize line:\n```kql\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where operation_Name == 'Success report generation' // do note that in a later version of the schema, this field will not be used\n     or customDimensions.eventId == 'RT0006'          // introduced in version 16.1\n| where customDimensions.result == 'Success'\n| take 100\n| project timestamp\n// in which environment/company did it happen\n, aadTenantId = customDimensions.aadTenantId\n, environmentName = customDimensions.environmentName\n, environmentType = customDimensions.environmentType\n// in which extension/app\n, extensionId = customDimensions.extensionId\n, extensionName = customDimensions.extensionName\n, extensionVersion = customDimensions.extensionVersion\n, extensionPublisher = customDimensions.extensionPublisher\n// in which object\n, alObjectId = customDimensions.alObjectId\n, alObjectName = customDimensions.alObjectName\n, LayoutType = customDimensions.layoutType           // layout dimensions added in version 20.0\n, reportAction = customDimensions.reportAction       // reportAction dimension added in version 20.0\n| summarize count() by tostring(alObjectName)\n```\nThe error about grouping by a dynamic value is common when you write KQL. Now you know how to fix it.\nLet's add a few more columns to the by part of the summarize line and tidy up the query (remove comments and unused columns from the project part):\n```kql\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where customDimensions.eventId == 'RT0006'\n| where customDimensions.result == 'Success'\n| take 100\n| project extensionPublisher = customDimensions.extensionPublisher\n, alObjectName = customDimensions.alObjectName\n, LayoutType = customDimensions.layoutType\n, reportAction = customDimensions.reportAction\n| summarize count()\n  by tostring(alObjectName)\n   , tostring(LayoutType)\n   , tostring(reportAction)\n   , tostring(extensionPublisher)\n```\nIf we want the columns in the result to have some nice names, we can rename them directly in the summarize operator:\n```kql\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where customDimensions.eventId == 'RT0006'\n| where customDimensions.result == 'Success'\n| take 100\n| project extensionPublisher = customDimensions.extensionPublisher\n, alObjectName = customDimensions.alObjectName\n, LayoutType = customDimensions.layoutType\n, reportAction = customDimensions.reportAction\n| summarize report_count = count()\n  by report_name   = tostring(alObjectName)\n   , layout_type   = tostring(LayoutType)\n   , report_action = tostring(reportAction)\n   , publisher     = tostring(extensionPublisher)\n```\nWe want to see the most frequent reports in the top of the list, so we add a new line with an order by operator (remember to add _desc_ or _asc_):\n```kql\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where customDimensions.eventId == 'RT0006'\n| where customDimensions.result == 'Success'\n| take 100\n| project extensionPublisher = customDimensions.extensionPublisher\n, alObjectName = customDimensions.alObjectName\n, LayoutType = customDimensions.layoutType\n, reportAction = customDimensions.reportAction\n| summarize report_count = count()\n  by report_name   = tostring(alObjectName)\n   , layout_type   = tostring(LayoutType)\n   , report_action = tostring(reportAction)\n   , publisher     = tostring(extensionPublisher)\n| order by report_count desc\n```\nWe just want to see the top 10 results. So we add one more operator to the end of the query:\n```kql\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where customDimensions.eventId == 'RT0006'\n| where customDimensions.result == 'Success'\n| take 100\n| project extensionPublisher = customDimensions.extensionPublisher\n, alObjectName = customDimensions.alObjectName\n, LayoutType = customDimensions.layoutType\n, reportAction = customDimensions.reportAction\n| summarize report_count = count()\n  by report_name   = tostring(alObjectName)\n   , layout_type   = tostring(LayoutType)\n   , report_action = tostring(reportAction)\n   , publisher     = tostring(extensionPublisher)\n| order by report_count desc\n| take 10\n```\nOur query now delivers a result that looks like what we want. Final step is to deal with the initial `take 100` line as the query is now ready and we're no longer experimenting. For future experiments, we just comment it out, to make it easy to add again, should we need it:\n```kql\n// Final version\ntraces\n| where timestamp > ago(60d) // adjust as needed\n| where customDimensions.eventId == 'RT0006'\n| where customDimensions.result == 'Success'\n//| take 100\n| project extensionPublisher = customDimensions.extensionPublisher\n, alObjectName = customDimensions.alObjectName\n, LayoutType = customDimensions.layoutType\n, reportAction = customDimensions.reportAction\n| summarize report_count = count()\n  by report_name   = tostring(alObjectName)\n   , layout_type   = tostring(LayoutType)\n   , report_action = tostring(reportAction)\n   , publisher     = tostring(extensionPublisher)\n| order by report_count desc\n| take 10\n```\n## Related information\ntelemetry-overview\nEnabling telemetry<telemetry-enable-application-insights>\ntelemetry-available-telemetry\nAnalyze Telemetry with Power BI<telemetry-power-bi-app>\ntelemetry-faq"}