Enable application monitoring in Azure App Service for .NET, Node.js, Python, and Java applications

2025-10-29

Autoinstrumentation, also referred to as runtime monitoring, is the easiest way to enable Application Insights for Azure App Service without requiring any code changes or advanced configurations. Based on your specific scenario, evaluate whether you require more advanced monitoring through manual instrumentation.

Note

On March 31, 2025, support for instrumentation key ingestion will end. Instrumentation key ingestion will continue to work, but we'll no longer provide updates or support for the feature. Transition to connection strings to take advantage of new capabilities.

Enable Application Insights

Important

If both autoinstrumentation monitoring and manual SDK-based instrumentation are detected, only the manual instrumentation settings are honored. This arrangement prevents duplicate data from being sent. To learn more, see Troubleshoot Application Insights integration with Azure App Service.

Note

Only .NET Core Long Term Support (LTS) releases are supported.
Trim self-contained deployments is not supported. Use manual instrumentation instead.

Autoinstrumentation in the Azure portal

Select Application Insights in the left-hand navigation menu of your app service, then select Enable.
Create a new resource or select an existing Application Insights resource for this application.

Note

When you select OK to create a new resource, you're prompted to Apply monitoring settings. Selecting Continue links your new Application Insights resource to your app service. Your app service then restarts.
After you specify which resource to use, you can choose how you want Application Insights to collect data per platform for your application. ASP.NET Core collection options are Recommended or Disabled.

Important

Note

The combination of APPINSIGHTS_JAVASCRIPT_ENABLED and urlCompression isn't supported.

Autoinstrumentation in the Azure portal

Select Application Insights in the left-hand navigation menu of your app service, then select Enable.
Create a new resource or select an existing Application Insights resource for this application.

Note

When you select OK to create a new resource, you're prompted to Apply monitoring settings. Selecting Continue links your new Application Insights resource to your app service. Your app service then restarts.

After you specify which resource to use, you can choose how you want Application Insights to collect data per platform for your application. ASP.NET app monitoring is on by default with two different levels of collection, Recommended and Basic.

Screenshot that shows the Application Insights site extensions page with Create new resource selected.

The following table summarizes the data collected for each route.

Data	Recommended	Basic
Adds CPU, memory, and I/O usage trends	Yes	No
Collects usage trends, and enables correlation from availability results to transactions	Yes	Yes
Collects exceptions unhandled by the host process	Yes	Yes
Improves APM metrics accuracy under load, when sampling is used	Yes	Yes
Correlates micro-services across request/dependency boundaries	Yes	No (single-instance APM capabilities only)

Important

If both autoinstrumentation monitoring and manual SDK-based instrumentation are detected, only the manual instrumentation settings are honored. This arrangement prevents duplicate data from being sent. To learn more, see the Troubleshoot Application Insights integration with Azure App Service.

Note

You can configure the automatically attached agent using the APPLICATIONINSIGHTS_CONFIGURATION_CONTENT environment variable in the App Service Environment variable blade. For details on the configuration options that can be passed via this environment variable, see Node.js Configuration.

Application Insights for Node.js is integrated with Azure App Service on Linux - both code-based and custom containers, and with App Service on Windows for code-based apps. The integration is in public preview.

Autoinstrumentation in the Azure portal

Select Application Insights in the left-hand navigation menu of your app service, then select Enable.
Create a new resource or select an existing Application Insights resource for this application.

Note

When you select OK to create a new resource, you're prompted to Apply monitoring settings. Selecting Continue links your new Application Insights resource to your app service. Your app service then restarts.
Once you specified which resource to use, you're all set to go.

Note

Only use autoinstrumentation on App Service if you aren't using manual instrumentation of OpenTelemetry in your code, such as the Azure Monitor OpenTelemetry Distro or the Azure Monitor OpenTelemetry Exporter. This is to prevent duplicate data from being sent. To learn more about this, check out Troubleshoot Application Insights integration with Azure App Service.
Live Metrics isn't available for autoinstrumented Python applications running on Azure App Service. To use this feature, manually instrument your application with the Azure Monitor OpenTelemetry Distro instead.

Application Insights for Python integrates with code-based Linux Azure App Service Deploy as Code. Integration with Deploy as Container is not currently available. The integration is GA and adds the Python SDK, which is in GA. It instruments popular Python libraries in your code, letting you automatically gather and correlate dependencies, logs, and metrics. To see which calls and metrics are collected, see Python libraries

Logging telemetry is collected at the level of the root logger. To learn more about Python's native logging hierarchy, visit the Python logging documentation.

Prerequisites

Python versions 3.9-3.13
Linux OS
App Service must be Deployed as Code. Custom containers aren't supported.

Autoinstrumentation in the Azure portal

Select Application Insights in the left-hand navigation menu of your app service, then select Enable.
Create a new resource or select an existing Application Insights resource for this application.

Note

When you select OK to create a new resource, you're prompted to Apply monitoring settings. Selecting Continue links your new Application Insights resource to your app service. Your app service then restarts.
You specify the resource, and it's ready to use.

Python libraries

After instrumenting, you collect calls and metrics from these Python libraries:

Instrumentation	Supported library Name	Supported versions
OpenTelemetry Django Instrumentation	django	link
OpenTelemetry FastApi Instrumentation	fastapi	link
OpenTelemetry Flask Instrumentation	flask	link
OpenTelemetry Psycopg2 Instrumentation	psycopg2	link
OpenTelemetry Requests Instrumentation	requests	link
OpenTelemetry UrlLib Instrumentation	urllib	All
OpenTelemetry UrlLib3 Instrumentation	urllib3	link

Django instrumentation

In order to use the OpenTelemetry Django instrumentation, you need to set the DJANGO_SETTINGS_MODULE environment variable in the App Service settings to point from your app folder to your settings module.

For more information, see the Django documentation.

Add a community instrumentation library

You can collect more data automatically when you include instrumentation libraries from the OpenTelemetry community.

Caution

We don't support or guarantee the quality of community instrumentation libraries. To suggest one for our distro, post or up-vote in our feedback community. Be aware, some are based on experimental OpenTelemetry specs and might introduce future breaking changes.

To add the community OpenTelemetry Instrumentation Library, install it via your app's requirements.txt file. OpenTelemetry autoinstrumentation automatically picks up and instruments all installed libraries. Find the list of community libraries here.

Manually upgrade the monitoring extension/agent

Upgrade from versions 2.8.9 and up

Upgrading from version 2.8.9 happens automatically, without any extra actions. The new monitoring bits are delivered in the background to the target app service, and are picked up on application restart.

To check which version of the extension you're running, go to https://yoursitename.scm.azurewebsites.net/ApplicationInsights.

Screenshot that shows the URL path to check the version of the extension you're running.

Upgrade from versions 1.0.0 - 2.6.5

Starting with version 2.8.9, the preinstalled site extension is used. If you're using an earlier version, you can update via one of two ways:

Upgrade by enabling via the Azure portal: Even if you have the Application Insights extension for App Service installed, the UI shows only the Enable button. Behind the scenes, the old private site extension is removed.
Upgrade through PowerShell:
1. Set the application settings to enable the preinstalled site extension ApplicationInsightsAgent. For more information, see Enable through PowerShell.
2. Manually remove the private site extension named Application Insights extension for Azure App Service.

If the upgrade is done from a version before 2.5.1, check that the ApplicationInsights DLLs are removed from the application bin folder. For more information, see Troubleshoot Application Insights integration with Azure App Service.

Upgrade from versions 2.8.9 and up

To check which version of the extension you're running, go to https://yoursitename.scm.azurewebsites.net/ApplicationInsights.

Screenshot that shows the URL path to check the version of the extension you're running.

Upgrade from versions 1.0.0 - 2.6.5

Starting with version 2.8.9, the preinstalled site extension is used. If you're using an earlier version, you can update via one of two ways:

Upgrade by enabling via the Azure portal: Even if you have the Application Insights extension for App Service installed, the UI shows only the Enable button. Behind the scenes, the old private site extension is removed.
Upgrade through PowerShell:
1. Set the application settings to enable the preinstalled site extension ApplicationInsightsAgent. For more information, see Enable through PowerShell.
2. Manually remove the private site extension named Application Insights extension for Azure App Service.

The Application Insights Java version is updated automatically as part of App Service updates. If you encounter an issue that got fixed in the latest version of the Application Insights Java agent, you can update it manually.

Upload the Java agent jar file to App Service.

a. First, get the latest version of Azure CLI by following the instructions here.

b. Next, get the latest version of the Application Insights Java agent by following the instructions here.

c. Then, deploy the Java agent jar file to App Service using the following command: az webapp deploy --src-path applicationinsights-agent-{VERSION_NUMBER}.jar --target-path java/applicationinsights-agent-{VERSION_NUMBER}.jar --type static --resource-group {YOUR_RESOURCE_GROUP} --name {YOUR_APP_SVC_NAME}. Alternatively, you can use this guide to deploy the agent through the Maven plugin.
Disable Application Insights via the Application Insights tab in the Azure portal.
Once the agent jar file is uploaded, go to App Service configurations. If you need to use Startup Command for Linux, include JVM arguments:

Startup Command doesn't honor JAVA_OPTS for JavaSE or CATALINA_OPTS for Tomcat.

If you don't use Startup Command, create a new environment variable, JAVA_OPTS for JavaSE or CATALINA_OPTS for Tomcat, with the value -javaagent:{PATH_TO_THE_AGENT_JAR}/applicationinsights-agent-{VERSION_NUMBER}.jar.
To apply the changes, restart the app.

Note

If you set the JAVA_OPTS for JavaSE or CATALINA_OPTS for Tomcat environment variable, you have to disable Application Insights in the Azure portal. Alternatively, if you prefer to enable Application Insights from the Azure portal, make sure that you don't set the JAVA_OPTS for JavaSE or CATALINA_OPTS for Tomcat variable in App Service configurations settings.

Configure the monitoring extension/agent

We currently don't offer options to configure the monitoring extension for ASP.NET Core.

To configure sampling, which you could previously control via the applicationinsights.config file, you can now interact with it via application settings with the corresponding prefix MicrosoftAppInsights_AdaptiveSamplingTelemetryProcessor.

For example, to change the initial sampling percentage, you can create an application setting of MicrosoftAppInsights_AdaptiveSamplingTelemetryProcessor_InitialSamplingPercentage and a value of 100.
To disable sampling, set MicrosoftAppInsights_AdaptiveSamplingTelemetryProcessor_MinSamplingPercentage to a value of 100.
Supported settings include:
- MicrosoftAppInsights_AdaptiveSamplingTelemetryProcessor_InitialSamplingPercentage
- MicrosoftAppInsights_AdaptiveSamplingTelemetryProcessor_MinSamplingPercentage
- MicrosoftAppInsights_AdaptiveSamplingTelemetryProcessor_EvaluationInterval
- MicrosoftAppInsights_AdaptiveSamplingTelemetryProcessor_MaxTelemetryItemsPerSecond
For the list of supported adaptive sampling telemetry processor settings and definitions, see the code and sampling documentation.

After specifying which resource to use, you can configure the Java agent. If you don't configure the Java agent, default configurations apply.

The full set of configurations is available. You just need to paste a valid json file. Exclude the connection string and any configurations that are in preview - you're able to add the items that are currently in preview as they become generally available.

Once you modify the configurations through the Azure portal, APPLICATIONINSIGHTS_CONFIGURATION_FILE environment variable are automatically populated and appear in App Service settings panel. This variable contains the full json content that you pasted in the Azure portal configuration text box for your Java app.

Screenshot of instrument your application.

The Node.js agent can be configured using JSON. Set the APPLICATIONINSIGHTS_CONFIGURATION_CONTENT environment variable to the JSON string or set the APPLICATIONINSIGHTS_CONFIGURATION_FILE environment variable to the file path containing the JSON.

"samplingPercentage": 80,
"enableAutoCollectExternalLoggers": true,
"enableAutoCollectExceptions": true,
"enableAutoCollectHeartbeat": true,
"enableSendLiveMetrics": true,
...

The full set of configurations is available. You just need to use a valid json file.

You can configure with OpenTelemetry environment variables such as:

Environment Variable	Description
`OTEL_SERVICE_NAME`, `OTEL_RESOURCE_ATTRIBUTES`	Specifies the OpenTelemetry Resource Attributes associated with your application. You can set any Resource Attributes with OTEL_RESOURCE_ATTRIBUTES or use OTEL_SERVICE_NAME to only set the `service.name`.
`OTEL_LOGS_EXPORTER`	If set to `None`, disables collection and export of logging telemetry.
`OTEL_METRICS_EXPORTER`	If set to `None`, disables collection and export of metric telemetry.
`OTEL_TRACES_EXPORTER`	If set to `None`, disables collection and export of distributed tracing telemetry.
`OTEL_BLRP_SCHEDULE_DELAY`	Specifies the logging export interval in milliseconds. Defaults to 5000.
`OTEL_BSP_SCHEDULE_DELAY`	Specifies the distributed tracing export interval in milliseconds. Defaults to 5000.
`OTEL_TRACES_SAMPLER_ARG`	Specifies the ratio of distributed tracing telemetry to be sampled. Accepted values range from 0 to 1. The default is 1.0, meaning no telemetry is sampled out.
`OTEL_PYTHON_DISABLED_INSTRUMENTATIONS`	Specifies which OpenTelemetry instrumentations to disable. When disabled, instrumentations aren't executed as part of autoinstrumentation. Accepts a comma-separated list of lowercase library names. For example, set it to `"psycopg2,fastapi"` to disable the Psycopg2 and FastAPI instrumentations. It defaults to an empty list, enabling all supported instrumentations.

Enable client-side monitoring

Client-side monitoring is enabled by default for ASP.NET Core apps with Recommended collection, regardless of whether the app setting APPINSIGHTS_JAVASCRIPT_ENABLED is present.

If you want to disable client-side monitoring:

Select Settings > Configuration.
Under Application settings, create a New application setting with the following information:
- Name: APPINSIGHTS_JAVASCRIPT_ENABLED
- Value: false
Save the settings. Restart your app.

Automate monitoring

In order to enable telemetry collection with Application Insights, only the following Application settings need to be set:

Screenshot that shows App Service application settings with Application Insights settings.

Application settings definitions

App setting name	Definition	Value
ApplicationInsightsAgent_EXTENSION_VERSION	Main extension, which controls runtime monitoring.	`~2` for Windows or `~3` for Linux
XDT_MicrosoftApplicationInsights_Mode	In default mode, only essential features are enabled to ensure optimal performance.	`disabled` or `recommended`.
XDT_MicrosoftApplicationInsights_PreemptSdk	For ASP.NET Core apps only. Enables Interop (interoperation) with the Application Insights SDK. Loads the extension side by side with the SDK and uses it to send telemetry. (Disables the Application Insights SDK.)	`1`

Screenshot that shows App Service application settings with Application Insights settings.

Application settings definitions

App setting name	Definition	Value
ApplicationInsightsAgent_EXTENSION_VERSION	Main extension, which controls runtime monitoring.	`~2`
XDT_MicrosoftApplicationInsights_Mode	In default mode, only essential features are enabled to ensure optimal performance.	`default` or `recommended`
InstrumentationEngine_EXTENSION_VERSION	Controls if the binary-rewrite engine `InstrumentationEngine` are turned on. This setting has performance implications and affects cold start/startup time.	`~1`
XDT_MicrosoftApplicationInsights_BaseExtensions	Controls if SQL and Azure table text are captured along with the dependency calls. Performance warning: Application cold startup time is affected. This setting requires the `InstrumentationEngine`.	`~1`

Screenshot of App Service Application Settings with available Application Insights settings.

Application settings definitions

App setting name	Definition	Value
ApplicationInsightsAgent_EXTENSION_VERSION	Main extension, which controls runtime monitoring.	`~2` in Windows or `~3` in Linux.
XDT_MicrosoftApplicationInsights_Java	Flag to control if Java agent is included.	`0` or `1` (only applicable in Windows).

Note

Snapshot Debugger isn't available for Java applications.

Screenshot of App Service Application Settings with available Application Insights settings.

Application settings definitions

App setting name	Definition	Value
ApplicationInsightsAgent_EXTENSION_VERSION	Main extension, which controls runtime monitoring.	`~2` in Windows or `~3` in Linux.
XDT_MicrosoftApplicationInsights_NodeJS	Flag to control if Node.js agent is included.	`0` or `1` (only applicable in Windows).

Note

Snapshot Debugger isn't available for Node.js applications.

Application settings definitions

App setting name	Definition	Value
APPLICATIONINSIGHTS_CONNECTION_STRING	Connections string for your Application Insights resource.	Example: abcd1234-ab12-cd34-abcd1234abcd
ApplicationInsightsAgent_EXTENSION_VERSION	Main extension, which controls runtime monitoring.	`~3`

Note

Snapshot Debugger isn't available for Python applications.

App Service application settings with Azure Resource Manager

Application settings for Azure App Service can be managed and configured with Azure Resource Manager templates. You can use this method when you deploy new App Service resources with Resource Manager automation or modify the settings of existing resources.

The basic structure of the application settings JSON for an App Service resource:

      "resources": [
        {
          "name": "appsettings",
          "type": "config",
          "apiVersion": "2015-08-01",
          "dependsOn": [
            "[resourceId('Microsoft.Web/sites', variables('webSiteName'))]"
          ],
          "tags": {
            "displayName": "Application Insights Settings"
          },
          "properties": {
            "key1": "value1",
            "key2": "value2"
          }
        }
      ]

Automate the creation of an Application Insights resource and link to your newly created App Service resource

To create a Resource Manager template with the default Application Insights settings, begin the process as if you were going to create a new web app with Application Insights enabled.

In the Azure portal, create a new Web App resource with your desired information. Enable Application Insights on the Monitor + secure tab.
Go to Review + create, then select Download a template for automation. This option generates the latest Resource Manager template with all required settings configured.

Note

The following example template is for a .NET 8 (LTS) application running on Windows. It uses the placeholders my-monitored-web-app for the name of the application and aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e for the subscription ID.

We don't recommend copying and using it directly. Instead, generate your own template based on the instructions above.

Expand to view example template

{
    "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "subscriptionId": {
            "type": "string"
        },
        "resourceGroupName": {
            "type": "string"
        },
        "name": {
            "type": "string"
        },
        "location": {
            "type": "string"
        },
        "hostingPlanName": {
            "type": "string"
        },
        "serverFarmResourceGroup": {
            "type": "string"
        },
        "alwaysOn": {
            "type": "bool"
        },
        "ftpsState": {
            "type": "string"
        },
        "autoGeneratedDomainNameLabelScope": {
            "type": "string"
        },
        "sku": {
            "type": "string"
        },
        "skuCode": {
            "type": "string"
        },
        "workerSize": {
            "type": "string"
        },
        "workerSizeId": {
            "type": "string"
        },
        "numberOfWorkers": {
            "type": "string"
        },
        "currentStack": {
            "type": "string"
        },
        "phpVersion": {
            "type": "string"
        },
        "netFrameworkVersion": {
            "type": "string"
        }
    },
    "variables": {},
    "resources": [
        {
            "apiVersion": "2022-03-01",
            "name": "[parameters('name')]",
            "type": "Microsoft.Web/sites",
            "location": "[parameters('location')]",
            "tags": null,
            "dependsOn": [
                "microsoft.insights/components/my-monitored-web-app",
                "[concat('Microsoft.Web/serverfarms/', parameters('hostingPlanName'))]"
            ],
            "properties": {
                "name": "[parameters('name')]",
                "siteConfig": {
                    "appSettings": [
                        {
                            "name": "APPLICATIONINSIGHTS_CONNECTION_STRING",
                            "value": "[reference('microsoft.insights/components/my-monitored-web-app', '2015-05-01').ConnectionString]"
                        },
                        {
                            "name": "ApplicationInsightsAgent_EXTENSION_VERSION",
                            "value": "~2"
                        },
                        {
                            "name": "XDT_MicrosoftApplicationInsights_Mode",
                            "value": "default"
                        }
                    ],
                    "metadata": [
                        {
                            "name": "CURRENT_STACK",
                            "value": "[parameters('currentStack')]"
                        }
                    ],
                    "phpVersion": "[parameters('phpVersion')]",
                    "netFrameworkVersion": "[parameters('netFrameworkVersion')]",
                    "alwaysOn": "[parameters('alwaysOn')]",
                    "ftpsState": "[parameters('ftpsState')]"
                },
                "serverFarmId": "[concat('/subscriptions/', parameters('subscriptionId'),'/resourcegroups/', parameters('serverFarmResourceGroup'), '/providers/Microsoft.Web/serverfarms/', parameters('hostingPlanName'))]",
                "clientAffinityEnabled": true,
                "virtualNetworkSubnetId": null,
                "httpsOnly": true,
                "publicNetworkAccess": "Enabled",
                "autoGeneratedDomainNameLabelScope": "[parameters('autoGeneratedDomainNameLabelScope')]"
            },
            "resources": [
                {
                    "type": "Microsoft.Web/sites/basicPublishingCredentialsPolicies",
                    "apiVersion": "2022-09-01",
                    "name": "[concat(parameters('name'), '/scm')]",
                    "properties": {
                        "allow": true
                    },
                    "dependsOn": [
                        "[resourceId('Microsoft.Web/Sites', parameters('name'))]"
                    ]
                },
                {
                    "type": "Microsoft.Web/sites/basicPublishingCredentialsPolicies",
                    "apiVersion": "2022-09-01",
                    "name": "[concat(parameters('name'), '/ftp')]",
                    "properties": {
                        "allow": true
                    },
                    "dependsOn": [
                        "[resourceId('Microsoft.Web/Sites', parameters('name'))]"
                    ]
                }
            ]
        },
        {
            "apiVersion": "2018-11-01",
            "name": "[parameters('hostingPlanName')]",
            "type": "Microsoft.Web/serverfarms",
            "location": "[parameters('location')]",
            "kind": "",
            "tags": null,
            "dependsOn": [],
            "properties": {
                "name": "[parameters('hostingPlanName')]",
                "workerSize": "[parameters('workerSize')]",
                "workerSizeId": "[parameters('workerSizeId')]",
                "numberOfWorkers": "[parameters('numberOfWorkers')]",
                "zoneRedundant": false
            },
            "sku": {
                "Tier": "[parameters('sku')]",
                "Name": "[parameters('skuCode')]"
            }
        },
        {
            "apiVersion": "2020-02-02-preview",
            "name": "my-monitored-web-app",
            "type": "microsoft.insights/components",
            "location": "centralus",
            "tags": null,
            "dependsOn": [
                "newWorkspaceTemplate"
            ],
            "properties": {
                "ApplicationId": "[parameters('name')]",
                "Request_Source": "IbizaWebAppExtensionCreate",
                "Flow_Type": "Redfield",
                "Application_Type": "web",
                "WorkspaceResourceId": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/DefaultResourceGroup-CUS/providers/Microsoft.OperationalInsights/workspaces/DefaultWorkspace-aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e-CUS"
            }
        },
        {
            "type": "Microsoft.Resources/deployments",
            "apiVersion": "2021-04-01",
            "name": "newWorkspaceTemplate",
            "resourceGroup": "DefaultResourceGroup-CUS",
            "subscriptionId": "[parameters('subscriptionId')]",
            "properties": {
                "mode": "Incremental",
                "template": {
                    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
                    "contentVersion": "1.0.0.0",
                    "parameters": {},
                    "variables": {},
                    "resources": [
                        {
                            "apiVersion": "2020-08-01",
                            "name": "DefaultWorkspace-aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e-CUS",
                            "type": "Microsoft.OperationalInsights/workspaces",
                            "location": "centralus",
                            "properties": {}
                        }
                    ]
                }
            }
        }
    ]
}

Enable through PowerShell

To enable the application monitoring through PowerShell, only the underlying application settings must be changed. The following sample enables application monitoring for a website called my-monitored-web-app in the resource group my-resource-group. It configures data to be sent to the InstrumentationKey=012345678-abcd-ef01-2345-6789abcd connection string.

Note

We recommend that you use the Azure Az PowerShell module to interact with Azure. To get started, see Install Azure PowerShell. To learn how to migrate to the Az PowerShell module, see Migrate Azure PowerShell from AzureRM to Az.

Note

For Windows, set ApplicationInsightsAgent_EXTENSION_VERSION to ~2.

For Linux, set ApplicationInsightsAgent_EXTENSION_VERSION to ~3.

$app = Get-AzWebApp -ResourceGroupName "my-resource-group" -Name "my-monitored-web-app" -ErrorAction Stop
$newAppSettings = @{} # Case-insensitive hash map
$app.SiteConfig.AppSettings | %{$newAppSettings[$_.Name] = $_.Value} # Preserve non-Application-Insights application settings.
$newAppSettings["APPLICATIONINSIGHTS_CONNECTION_STRING"] = "InstrumentationKey=aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e"; # Set the Application Insights connection string
$newAppSettings["ApplicationInsightsAgent_EXTENSION_VERSION"] = "~3"; # Enable the ApplicationInsightsAgent.
$app = Set-AzWebApp -AppSettings $newAppSettings -ResourceGroupName $app.ResourceGroup -Name $app.Name -ErrorAction Stop

Troubleshooting

See the dedicated troubleshooting article.

Next steps

Review frequently asked questions (FAQ): Monitoring in Azure App Service for .NET, Node.js, Python, and Java applications FAQ.
Enable the .NET Profiler for Azure App Service apps on your live app.
Enable Azure diagnostics to be sent to Application Insights.
Monitor service health metrics to make sure your service is available and responsive.
Receive alert notifications whenever operational events happen or metrics cross a threshold.
Set up availability tests for your application.

Feedback

Was this page helpful?

Share via

Enable application monitoring in Azure App Service for .NET, Node.js, Python, and Java applications

Enable Application Insights

Autoinstrumentation in the Azure portal

Manually upgrade the monitoring extension/agent

Upgrade from versions 2.8.9 and up

Upgrade from versions 1.0.0 - 2.6.5

Configure the monitoring extension/agent

Enable client-side monitoring

Automate monitoring

Application settings definitions

App Service application settings with Azure Resource Manager

Automate the creation of an Application Insights resource and link to your newly created App Service resource

Enable through PowerShell

Troubleshooting

Next steps

Feedback

Additional resources