Azure App Service Monitoring & Alerting Recommendations for Production Applications

Selvam Sekar 120 Reputation points
2026-09-22T14:12:12.1633333+00:00

Hi,

I am looking to strengthen monitoring and alerting for our production Azure App Services and would appreciate guidance on the best approach for configuring the following alerts and metrics.

Applications:

  • API Web App
  • UI Web App

Key monitoring requirements:

  • CPU Utilization: Alert on abnormal CPU spikes or sustained high CPU usage.
  • Memory Utilization: Alert on high memory consumption and potential resource constraints.
  • Application Availability: Monitor application uptime and notify on service unavailability.
  • Consecutive Failures: Alert on repeated request failures, transaction failures, or recurring application errors.
  • Performance Degradation: Monitor response times, latency, and throughput, with alerts when thresholds are exceeded.
  • Overall Health Monitoring: Proactively detect infrastructure or application issues that may impact end users.

While reviewing the App Service metrics, we noticed that only metrics such as CPU Time are available and do not see direct metrics for CPU or Memory utilization.

Could the community please advise:

  1. What is the recommended approach for monitoring CPU and Memory utilization for Azure App Services?
  2. Are there native Azure Monitor metrics available, or should Application Insights / Log Analytics (KQL-based alerts) be used?
  3. What are the best practices for configuring availability, performance, and health alerts for production App Services?

Thanks,

Selvam.

Azure App Service
Azure App Service

Azure App Service is a service used to create and deploy scalable, mission-critical web apps.

0 comments
Answer accepted by question author
Jose Benjamin Solis Nolasco 12,691 Reputation points Volunteer Moderator
2026-09-22T20:25:50.37+00:00

Welcome to Microsoft Q&A,

@Selvam Sekar I hope you are doing well,

For production App Services, I recommend a layered monitoring approach using Azure Monitor metrics + Application Insights + Health Check.

  1. CPU and memory App Service provides native Azure Monitor metrics. For Web Apps, the relevant metrics include:
    • CPU Time – CPU consumed by the application, rather than a direct CPU percentage.
    • Average Memory Working Set / Memory Working Set – memory used by the application.
    • Requests and Response Time for workload and performance.
    These metrics can be used directly with Azure Monitor metric alerts. A direct Percentage CPU metric is currently documented for Flex Consumption Function Apps, not standard Web Apps.
  2. Application performance and failures Enable Application Insights for both the API and UI. It provides application-level telemetry such as request duration, failed requests, exceptions, dependencies, and availability tests. Use metric alerts for straightforward thresholds and Log Analytics/KQL alerts when you need more complex conditions.
  3. Availability and health Configure App Service Health Check with a dedicated /health endpoint. The endpoint should validate critical dependencies when appropriate, such as the database or messaging services. Health Check runs against each instance and can remove unhealthy instances from the load balancer. For external/user-perspective availability, also consider Application Insights availability tests.
    1. Recommended production alerts
    I would start with: CPU Time 
      Average Memory Working Set

     Response Time

        HTTP 5xx / failed requests

           Request volume

              Application Insights exceptions and dependency failures

                 Availability test failures

                    Resource Health / Service Health events

                    Avoid creating an alert for every metric. Define thresholds based on the application's normal baseline and use dynamic thresholds where appropriate, you will be fine....

Microsoft references:

https://learn.microsoft.com/en-us/azure/azure-monitor/reference/supported-metrics/microsoft-web-sites-metrics

https://learn.microsoft.com/en-us/azure/azure-monitor/app/codeless-app-service

https://learn.microsoft.com/en-us/azure/app-service/monitor-instances-health-check

https://learn.microsoft.com/en-us/azure/app-service/web-sites-monitor

https://learn.microsoft.com/en-us/azure/troubleshoot/azure/app-service/troubleshoot-performance-degradation

If this answer helped clarify the platform capabilities and save you troubleshooting time, please consider marking it as Accepted. This helps others in the community find similar solutions.

Was this answer helpful?

1 person found this answer helpful.
0 comments

1 additional answer

Sort by: Most helpful
Most helpful Newest Oldest

  1. AI answer

    2026-09-22T14:12:37.0933333+00:00

    For production Azure App Services, use a layered approach:

    1. Platform monitoring with Azure Monitor metrics and alerts for resource and service signals.
    2. Application Insights for application performance, failures, and deeper observability.
    3. Activity log alerts and Health signals for operational events and service/resource health.
    4. App Service diagnostics for investigation when alerts fire.

    For CPU and memory monitoring:

    1. In the Azure portal, open the App Service and go to Monitoring > Metrics.
    2. Monitor the metrics called out for App Service troubleshooting, including:
      • CPU time
      • Average memory working set
      • Memory working set
      • Requests
      • Response time
    3. Create metric alerts on these signals. Azure Monitor metric alerts evaluate resource metrics at regular intervals and can use multiple conditions and dynamic thresholds.
    4. Where fixed thresholds are hard to choose, use dynamic thresholds as a best practice for abnormal spikes and sustained deviations.

    For the question about direct CPU or memory utilization metrics:

    • Native Azure Monitor metrics are available for App Service, but the documented App Service metrics highlighted for monitoring include CPU time and memory working set rather than a direct CPU percentage metric in the App Service view.
    • For application-level performance and richer telemetry, use Application Insights. It is the recommended observability option for ASP.NET Core, ASP.NET, Java, Node.js, and Python apps, and it provides more alerting options.

    Recommended alert configuration for the requirements listed:

    1. CPU utilization / abnormal spikes
      • Use metric alerts on CPU time.
      • Prefer dynamic thresholds when normal load varies.
    2. Memory utilization / resource constraints
      • Use metric alerts on Average memory working set or Memory working set.
      • Also review Quotas and alerts because App Service apps are subject to plan resource limits.
    3. Application availability
      • Use Azure Health check to monitor App Service instances.
      • If the app is on the Standard pricing tier, configure endpoint monitoring. It tests up to two endpoints from three geographic locations every five minutes using HTTP GET, and a test fails if the response code is 400 or higher or if the response takes more than 30 seconds.
      • Use activity log alerts for Resource Health and Service Health events.
    4. Consecutive failures / recurring errors
      • Use Application Insights for application failures and transaction monitoring.
      • Use log alerts when a Log Analytics query should evaluate logs on a schedule.
      • For HTTP failures, App Service documentation lists recommended metric alerts such as:
        • HTTP 404
        • HTTP server errors for HTTP 5xx
    5. Performance degradation
      • Monitor and alert on:
        • Response time
        • Requests
        • CPU time
        • Memory working set
      • Use Application Insights for application performance and usage monitoring.
    6. Overall health monitoring
      • Use Diagnose and solve problems from the App Service left navigation for built-in diagnostics.
      • Check Advisor recommendations under Monitoring for critical conditions or imminent changes.
      • Add activity log alerts for operational events such as:
        • Create or update web app
        • Delete web app
        • Restart web app
        • Stop web app

    Best-practice setup for a production App Service:

    1. Enable Application Insights for both the API and UI apps.
    2. Create metric alerts for:
      • CPU time
      • Average memory working set
      • Response time
      • Requests
      • HTTP 5xx
      • HTTP 404 where relevant
    3. Add activity log alerts for Service Health, Resource Health, restart, stop, delete, and update events.
    4. Use dynamic thresholds where workload patterns vary.
    5. If monitoring multiple similar App Services in the same region, consider one alert rule for multiple resources to reduce management overhead.
    6. Use alert processing rules and custom properties to improve alert routing and diagnostics at scale.
    7. Use Logic Apps if customized notification workflows are required.

    This combination covers platform resource pressure, app failures, availability, and operational health without relying on a single signal.

    AI-generated content may be incorrect. Read our transparency notes for more information.

    Was this answer helpful?

Your answer

Answers can be marked as 'Accepted' by the question author and 'Recommended' by moderators, which helps users know the answer solved the author's problem.