- Article
Azure App Service providesbuilt-in monitoring functionality for web apps, mobile, and API apps in the Azure portal.
In the Azure portal, you can review quotas and metrics for an app and App Service plan, and set up alerts and autoscaling rules based metrics.
Understand quotas
Apps that are hosted in App Service are subject to certain limits on the resources they can use. The limits are defined by the App Service plan that's associated with the app.
Note
App Service Free and Shared (preview) service plans are base tiers that run on the same Azure virtual machines as other App Service apps. Some apps might belong to other customers. These tiers are intended to be used only for development and testing purposes.
If the app is hosted in a Free or Shared plan, the limitson the resources that the app can use are defined by quotas.
If the app is hosted in a Basic, Standard, or Premium plan, the limits on the resources that they can use are set by the size (Small, Medium, Large) and instance count (1, 2, 3, and so on) of the App Service plan.
Quotas for Free or Shared apps are:
| Quota | Description |
|---|---|
| CPU (Short) | The amount of CPU allowed for this app in a 5-minute interval. This quota resets every five minutes. |
| CPU (Day) | The total amount of CPU allowed for this app in a day. This quota resets every 24 hours at midnight UTC. |
| Memory | The total amount of memory allowed for this app. |
| Bandwidth | The total amount of outgoing bandwidth allowed for this app in a day. This quota resets every 24 hours at midnight UTC. |
| Filesystem | The total amount of storage allowed. |
The only quota applicable to apps that are hosted in Basic, Standard, andPremium is Filesystem.
For more information about the specific quotas, limits, and features available to the various App Service SKUs, see Azure Subscription service limits.
Quota enforcement
If an app exceeds the CPU (short), CPU (Day), or bandwidth quota, the app is stopped until the quota resets. During this time, all incoming requests result in an HTTP 403 error.
If the app Memory quota is exceeded, the app is stopped temporarily.
If the Filesystem quota is exceeded, any write operation fails. Write operation failures include any writes to logs.
You can increase or remove quotas from your app by upgrading your App Service plan.
Understand metrics
Important
Average Response Time will be deprecated to avoid confusion with metric aggregations. Use Response Time as a replacement.
Note
Metrics for an app include the requests to the app's SCM site(Kudu). This includes requests to view the site's logstream using Kudu. Logstream requests may span several minutes, which will affect the Request Time metrics. Users should be aware of this relationship when using these metrics with autoscale logic.
Http Server Errors only records requests that reach the backend service (the worker(s) hosting the app). If the requests are failing at the FrontEnd, they are not recorded as Http Server Errors. The Health Check feature / Application Insights availability tests can be used for outside in monitoring.
Metrics provide information about the app or the App Service plan's behavior.
For an app, the available metrics are:
| Metric | Description |
|---|---|
| Response Time | The time taken for the app to serve requests, in seconds. |
| Average Response Time (deprecated) | The average time taken for the app to serve requests, in seconds. |
| Average memory working set | The average amount of memory used by the app, in megabytes (MiB). |
| Connections | The number of bound sockets existing in the sandbox (w3wp.exe and its child processes). A bound socket is created by calling bind()/connect() APIs and remains until said socket is closed with CloseHandle()/closesocket(). |
| CPU Time | The amount of CPU consumed by the app, in seconds. For more information about this metric, see CPU time vs CPU percentage. |
| Current Assemblies | The current number of Assemblies loaded across all AppDomains in this application. |
| Data In | The amount of incoming bandwidth consumed by the app, in MiB. |
| Data Out | The amount of outgoing bandwidth consumed by the app, in MiB. |
| File System Usage | The amount of usage in bytes by storage share. |
| Gen 0 Garbage Collections | The number of times the generation 0 objects are garbage collected since the start of the app process. Higher generation GCs include all lower generation GCs. |
| Gen 1 Garbage Collections | The number of times the generation 1 objects are garbage collected since the start of the app process. Higher generation GCs include all lower generation GCs. |
| Gen 2 Garbage Collections | The number of times the generation 2 objects are garbage collected since the start of the app process. |
| Handle Count | The total number of handles currently open by the app process. |
| Health Check Status | The average health status across the application's instances in the App Service Plan. |
| Http 2xx | The count of requests resulting in an HTTP status code ≥ 200 but < 300. |
| Http 3xx | The count of requests resulting in an HTTP status code ≥ 300 but < 400. |
| Http 401 | The count of requests resulting in HTTP 401 status code. |
| Http 403 | The count of requests resulting in HTTP 403 status code. |
| Http 404 | The count of requests resulting in HTTP 404 status code. |
| Http 406 | The count of requests resulting in HTTP 406 status code. |
| Http 4xx | The count of requests resulting in an HTTP status code ≥ 400 but < 500. |
| Http Server Errors | The count of requests resulting in an HTTP status code ≥ 500 but < 600. |
| IO Other Bytes Per Second | The rate at which the app process is issuing bytes to I/O operations that don't involve data, such as control operations. |
| IO Other Operations Per Second | The rate at which the app process is issuing I/O operations that aren't read or write operations. |
| IO Read Bytes Per Second | The rate at which the app process is reading bytes from I/O operations. |
| IO Read Operations Per Second | The rate at which the app process is issuing read I/O operations. |
| IO Write Bytes Per Second | The rate at which the app process is writing bytes to I/O operations. |
| IO Write Operations Per Second | The rate at which the app process is issuing write I/O operations. |
| Memory working set | The current amount of memory used by the app, in MiB. |
| Private Bytes | Private Bytes is the current size, in bytes, of memory that the app process has allocated that can't be shared with other processes. |
| Requests | The total number of requests regardless of their resulting HTTP status code. |
| Requests In Application Queue | The number of requests in the application request queue. |
| Thread Count | The number of threads currently active in the app process. |
| Total App Domains | The current number of AppDomains loaded in this application. |
| Total App Domains Unloaded | The total number of AppDomains unloaded since the start of the application. |
For an App Service plan, the available metrics are:
Note
App Service plan metrics are available only for plans in Basic, Standard, and Premium tiers.
| Metric | Description |
|---|---|
| CPU Percentage | The average CPU used across all instances of the plan. |
| Memory Percentage | The average memory used across all instances of the plan. |
| Data In | The average incoming bandwidth used across all instances of the plan. |
| Data Out | The average outgoing bandwidth used across all instances of the plan. |
| Disk Queue Length | The average number of both read and write requests that were queued on storage. A high disk queue length is an indication of an app that might be slowing down because of excessive disk I/O. |
| Http Queue Length | The average number of HTTP requests that had to sit on the queue before being fulfilled. A high or increasing HTTP Queue length is a symptom of a plan under heavy load. |
CPU time vs CPU percentage
There are two metrics that reflect CPU usage:
CPU Time: Useful for apps hosted in Free or Shared plans, because one of their quotas is defined in CPU minutes used by the app.
CPU percentage: Useful for apps hosted in Basic, Standard, and Premium plans, because they can be scaled out. CPU percentage is a good indication of the overall usage across all instances.
Metrics granularity and retention policy
Metrics for an app and app service plan are logged and aggregated by the service and retained according to these rules.
Monitoring quotas and metrics in the Azure portal
To review the status of the various quotas and metrics that affect an app, go to the Azure portal.
To find quotas, select Settings > Quotas. On the chart, you can review:
- The quota name.
- Its reset interval.
- Its current limit.
- Its current value.
You can access metrics directly from the resource Overview page. Here you'll see charts representing some of the apps metrics.
Clicking on any of those charts will take you to the metrics view where you can create custom charts, query different metrics and much more.
To learn more about metrics, see Monitor service metrics.
Alerts and autoscale
Metrics for an app or an App Service plan can be hooked up to alerts. For more information, see Receive alert notifications.
App Service apps hosted in Basic or higher App Service plans support autoscale. With autoscale, you can configure rules that monitor the App Service plan metrics. Rules can increase or decrease the instance count, which can provide additional resources as needed. Rules can also help you save money when the app is over-provisioned.
For more information about autoscale, see How to scale and Best practices for Azure Monitor autoscaling.
As an expert in Azure App Service and monitoring functionality, I have hands-on experience and a deep understanding of the concepts involved. Let me break down the key points mentioned in the provided article:
Azure App Service Overview:
- Functionality: Azure App Service provides built-in monitoring functionality for web apps, mobile apps, and API apps in the Azure portal.
Quotas and App Service Plans:
- Quota Definitions: Apps hosted in App Service have limits on resources defined by the associated App Service plan.
- Service Plans: Free and Shared plans are intended for development and testing. Basic, Standard, and Premium plans have size and instance count-based limits.
- Quotas for Free or Shared Apps:
- CPU (Short): Allowed CPU usage in a 5-minute interval.
- CPU (Day): Total CPU allowed in a day.
- Memory: Total allowed memory.
- Bandwidth: Outgoing bandwidth allowed in a day.
- Filesystem: Total storage allowed.
Quota Enforcement:
- Actions: If an app exceeds quotas, various actions are taken, including app stoppage or temporary suspension of specific functionalities.
- Upgrade Option: Quotas can be increased or removed by upgrading the App Service plan.
Metrics:
- Deprecated Metric: Average Response Time is deprecated, and Response Time is recommended as a replacement.
- App Metrics: Various metrics are available for app monitoring, such as Response Time, Average Memory Working Set, Connections, CPU Time, and more.
- App Service Plan Metrics: Metrics for App Service plans include CPU Percentage, Memory Percentage, Data In/Out, Disk Queue Length, and HTTP Queue Length.
Metric Granularity and Retention Policy:
- Logging and Aggregation: Metrics for apps and App Service plans are logged, aggregated, and retained based on specific rules.
Monitoring in Azure Portal:
- Quota Review: Quotas and metrics can be reviewed in the Azure portal under Settings > Quotas.
- Metrics Access: Metrics can be accessed directly from the resource Overview page, allowing users to create custom charts and query different metrics.
Alerts and Autoscaling:
- Alerts: Metrics can be configured to trigger alerts for proactive monitoring.
- Autoscale: Basic and higher App Service plans support autoscale, allowing for dynamic resource adjustments based on configured rules.
In summary, Azure App Service offers a comprehensive monitoring solution with detailed quotas, metrics, and the ability to set up alerts and autoscaling rules for efficient resource management.
