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 - Tracks errors, exceptions, and faults, offering clear insights for fast problem-solving and enhanced stability.

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

• Transaction search - 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 to add a filter.

   

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 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 transaction search view, select View in Logs in the top navigation bar and pick a query from the dropdown menu.

   

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

   

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.

   

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

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 determining whether there are performance issues related to particular types of clients.

   

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.

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.

Transaction search

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 logs and custom telemetry to Application Insights for more comprehensive monitoring.
• For an introduction to monitoring uptime and responsiveness, see the Availability overview.