Investigate failures, performance, and transactions with Application Insights

Application Insights collects telemetry from your application to help diagnosing failures and investigating slow transactions. It includes four essential tools:

• Failures view - Tracks errors, exceptions, and faults, offering clear insights for fast problem-solving and enhanced stability.

• Performance view - Quickly identifies and helps resolve application bottlenecks by displaying response times and operation counts.

• Search view - Enables users to locate and examine individual telemetry items such as page views, exceptions, and custom events.

• Transaction diagnostics - Helps to quickly identify issues in components through comprehensive insight into end-to-end transaction details.

Together, these tools ensure the ongoing health and efficiency of web applications. You can use them to pinpoint issues or enhancements that would have the most impact on users.

Overview

Filter telemetry

Default filters

All experiences allow you to filter telemetry by time range. In addition, each experience comes with its own default filter:

Add filters

You can filter events on the values of their properties. The available properties depend on the event or telemetry types you selected. To add a filter:

1. Select 👁 Filter icon
   to add a filter.

   👁 Filter pill
   

2. From the left dropdown list, select a property.

3. From the center dropdown list, select one of the following operators: =, !=, contains, or not contains.

4. From the right dropdown list, select all property values you want to filter on.

   Note

   Notice that the counts to the right of the filter values show how many occurrences there are in the current filtered set.

5. To add another filter, select 👁 Filter icon
   again.

Search telemetry

Use analytics data

All data collected by Application Insights is stored in Log Analytics. It provides a rich query language to analyze the requests that generated the exception you're investigating.

1. On either the performance, failures, or search view, select View in Logs in the top navigation bar and pick a query from the dropdown menu.

   👁 Screenshot of the top action bar with the 'View in logs' button highlighted.
   

2. This action takes you to the Logs view, where you can further modify the query or select a different one from the sidebar.

   👁 Screenshot showing the 'Logs' view.
   

Investigate telemetry

Analyze client-side performance and failures

If you instrument your web pages with Application Insights, you can gain visibility into page views, browser operations, and dependencies. Collecting this browser data requires adding a script to your web pages.

1. After you add the script, you can access page views and their associated performance metrics by selecting the Browser toggle on the Performance or Failures view.

   👁 Screenshot highlighting the 'Server / Browser' toggle below the top action bar.
   

   This view provides a visual summary of various telemetries of your application from the perspective of the browser.

   Tip

   For single-page applications (SPAs), turn on enableAutoRouteTracking for route changes so that each logical page creates its own page view and operation. Otherwise, multiple route changes can be correlated to a single operation and some page view durations can appear as 0.

2. For browser operations, the end-to-end transaction details view shows Page View Properties of the client requesting the page, including the type of browser and its location. This information can help determine whether there are performance issues related to particular types of clients.

   👁 Screenshot showing the 'End-to-end transaction details' view with the 'Page View Properties' section highlighted.
   

Transaction diagnostics experience

The Transaction diagnostics experience, also called End-to-end transaction details view, shows a Gantt chart of the transaction, which lists all events with their duration and response code.

This diagnostics experience automatically correlates server-side telemetry from across all your Application Insights monitored components into a single view and supports multiple resources. Application Insights detects the underlying relationship and allows you to easily diagnose the application component, dependency, or exception that caused a transaction slowdown or failure.

Selecting a specific event reveals its properties, including additional information like the underlying command or call stack.

This view has four key parts:

Release annotations

Release annotations mark deployments and other significant events on Application Insights charts, allowing correlation of changes with performance, failures, and usage.

Automatic annotations with Azure Pipelines

Azure Pipelines creates a release annotation during deployment when all the following conditions are true:

Configure annotations in a pipeline by using an inline script

If you don't use the tasks in the previous section, add an inline script in the deployment stage.

1. Open an existing pipeline or create a new one, and select a task under Stages.

2. Add a new Azure CLI task.

3. Select the Azure subscription. Set Script Type to PowerShell, and set Script Location to Inline.

4. Add the PowerShell script from step 2 in Create release annotations with the Azure CLI to Inline Script.

5. Add script arguments. Replace placeholders in angle brackets.

   -aiResourceId "<aiResourceId>" `
   -releaseName "<releaseName>" `
   -releaseProperties @{"ReleaseDescription"="<a description>";
    "TriggerBy"="<Your name>" }
   

   The following example shows metadata you can set in the optional releaseProperties argument by using build and release variables. Select Save.

   -releaseProperties @{
   "BuildNumber"="$(Build.BuildNumber)";
   "BuildRepositoryName"="$(Build.Repository.Name)";
   "BuildRepositoryProvider"="$(Build.Repository.Provider)";
   "ReleaseDefinitionName"="$(Build.DefinitionName)";
   "ReleaseDescription"="Triggered by $(Build.DefinitionName) $(Build.BuildNumber)";
   "ReleaseEnvironmentName"="$(Release.EnvironmentName)";
   "ReleaseId"="$(Release.ReleaseId)";
   "ReleaseName"="$(Release.ReleaseName)";
   "ReleaseRequestedFor"="$(Release.RequestedFor)";
   "ReleaseWebUrl"="$(Release.ReleaseWebUrl)";
   "SourceBranch"="$(Build.SourceBranch)";
   "TeamFoundationCollectionUri"="$(System.TeamFoundationCollectionUri)" }
   

Create release annotations with the Azure CLI

Use the following PowerShell script to create a release annotation from any process, without Azure DevOps.

1. Sign in to the Azure CLI.

2. Save the following script as CreateReleaseAnnotation.ps1.

   param(
    [parameter(Mandatory = $true)][string]$aiResourceId,
    [parameter(Mandatory = $true)][string]$releaseName,
    [parameter(Mandatory = $false)]$releaseProperties = @()
   )
   
   # Function to ensure all Unicode characters in a JSON string are properly escaped
   function Convert-UnicodeToEscapeHex {
    param (
    [parameter(Mandatory = $true)][string]$JsonString
    )
    $JsonObject = ConvertFrom-Json -InputObject $JsonString
    foreach ($property in $JsonObject.PSObject.Properties) {
    $name = $property.Name
    $value = $property.Value
    if ($value -is [string]) {
    $value = [regex]::Unescape($value)
    $OutputString = ""
    foreach ($char in $value.ToCharArray()) {
    $dec = [int]$char
    if ($dec -gt 127) {
    $hex = [convert]::ToString($dec, 16)
    $hex = $hex.PadLeft(4, '0')
    $OutputString += "\u$hex"
    }
    else {
    $OutputString += $char
    }
    }
    $JsonObject.$name = $OutputString
    }
    }
    return ConvertTo-Json -InputObject $JsonObject -Compress
   }
   
   $annotation = @{
    Id = [GUID]::NewGuid();
    AnnotationName = $releaseName;
    EventTime = (Get-Date).ToUniversalTime().GetDateTimeFormats("s")[0];
    Category = "Deployment"; #Application Insights only displays annotations from the "Deployment" Category
    Properties = ConvertTo-Json $releaseProperties -Compress
   }
   
   $annotation = ConvertTo-Json $annotation -Compress
   $annotation = Convert-UnicodeToEscapeHex -JsonString $annotation
   
   $accessToken = (az account get-access-token | ConvertFrom-Json).accessToken
   $headers = @{
    "Authorization" = "Bearer $accessToken"
    "Accept" = "application/json"
    "Content-Type" = "application/json"
   }
   $params = @{
    Headers = $headers
    Method = "Put"
    Uri = "https://management.azure.com$($aiResourceId)/Annotations?api-version=2015-05-01"
    Body = $annotation
   }
   Invoke-RestMethod @params
   

Call the script and pass values for the parameters. The -releaseProperties parameter is optional.

.\CreateReleaseAnnotation.ps1 `
 -aiResourceId "<aiResourceId>" `
 -releaseName "<releaseName>" `
 -releaseProperties @{"ReleaseDescription"="<a description>";
 "TriggerBy"="<Your name>" }

View annotations

Application Insights displays release annotations in the following experiences:

• Performance and Failures
• Usage
• Workbooks (for any time-series visualization)

Annotations are visualized as markers at the top of charts.

👁 A screenshot of the exceptions chart with annotations.

To enable annotations in a workbook, open Advanced Settings and then select Show annotations. Select any annotation marker to open release details such as requestor, source control branch, release pipeline, and environment.

Frequently asked questions

This section provides answers to common questions.

Search view

Transaction diagnostics

Next steps

• Learn more about using Application Map to spot performance bottlenecks and failure hotspots across all components of your application.
• Learn more about using the Availability view to set up recurring tests to monitor availability and responsiveness for your application.
• Learn how to use Log Analytics and write complex queries to gain deeper insights from your telemetry data.
• Learn how to send custom telemetry to Application Insights for more comprehensive monitoring.
• For an introduction to monitoring uptime and responsiveness, see the Availability overview.