tutorial

Azure App Service Uptime Monitoring: Beyond Application Insights

Why Azure Application Insights isn't enough for production uptime visibility, and how to set up external monitoring for Azure App Service, Azure Functions, and API Management with Vigilmon.

Azure Application Insights is a powerful observability platform. It captures request traces, exceptions, dependencies, and performance counters in rich detail. But there's a category of failure it fundamentally cannot detect: the cases where your Azure service is unreachable from the outside world.

When an App Service plan hits its quota, when a deployment leaves your app in a restart loop, when a VNet integration misconfiguration blocks traffic, or when Azure's front-end infrastructure has a regional hiccup — Application Insights goes quiet because no requests are reaching your app to be logged. You need an independent external monitor that doesn't rely on Azure's own infrastructure to tell you something is wrong.

Vigilmon runs probes from multiple geographic regions outside Azure, giving you the user's-eye view of your service availability.

What This Guide Covers

  • Limitations of Azure Application Insights for uptime monitoring
  • HTTP monitoring for Azure App Service and Azure Functions
  • Heartbeat monitoring for scheduled Function Apps (TimerTrigger)
  • Multi-region monitoring for global Azure deployments
  • Webhook integration with Azure Logic Apps

You'll need a free Vigilmon account — no credit card required.

Why Application Insights Isn't Enough

Application Insights is an APM tool, not an uptime monitor. The distinction matters:

It requires your app to be running. Application Insights SDK is embedded in your application. If the app isn't responding — because it crashed, hit its memory limit, failed to start after a deployment, or the App Service plan is out of instances — no data flows to Application Insights. The silence looks like normal operation.

Azure Availability Tests have blind spots. Application Insights does include Availability Tests (URL ping tests run from Azure data centers). But these probes run from within Azure's network. A routing issue between Azure regions, an Azure Front Door misconfiguration, or a problem with Azure's own DNS infrastructure can cause users outside Azure to see failures that these internal tests miss.

It doesn't cover your full stack. Your App Service might be fine, but if Azure API Management is rejecting requests, or an Azure Function downstream is timing out, Application Insights data from each service lives in separate workspaces and requires cross-service correlation to see the end-to-end picture.

External monitoring from Vigilmon runs completely independently of Azure's infrastructure, from multiple geographic regions, giving you ground truth about whether your service is reachable from the internet.

Step 1: Add a Health Endpoint to Your Azure App Service

Before setting up monitoring, add a dedicated health route. For a .NET 8 Web API:

// Program.cs
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHealthChecks()
    .AddSqlServer(builder.Configuration.GetConnectionString("DefaultConnection"))
    .AddRedis(builder.Configuration.GetConnectionString("Redis"));

var app = builder.Build();

app.MapHealthChecks("/health", new HealthCheckOptions
{
    ResponseWriter = async (context, report) =>
    {
        context.Response.ContentType = "application/json";
        var result = new
        {
            status = report.Status.ToString().ToLower(),
            checks = report.Entries.ToDictionary(
                e => e.Key,
                e => new { status = e.Value.Status.ToString().ToLower(), description = e.Value.Description }
            ),
            duration = report.TotalDuration.TotalMilliseconds
        };
        await context.Response.WriteAsJsonAsync(result);
    }
});

app.Run();

For a Node.js app on App Service:

// app.js
const sql = require('mssql');

app.get('/health', async (req, res) => {
    const checks = {};
    let status = 'ok';

    try {
        await sql.query('SELECT 1');
        checks.database = 'ok';
    } catch (err) {
        checks.database = `error: ${err.message}`;
        status = 'degraded';
    }

    const code = status === 'ok' ? 200 : 503;
    res.status(code).json({ status, checks, timestamp: new Date().toISOString() });
});

Verify it works:

curl https://your-app.azurewebsites.net/health
# {"status":"ok","checks":{"database":"ok"},"timestamp":"2026-06-30T10:00:00Z"}

Step 2: Set Up HTTP Monitoring in Vigilmon

  1. Log in to vigilmon.online and go to Monitors → New Monitor
  2. Choose HTTP / HTTPS
  3. Set the URL: https://your-app.azurewebsites.net/health
  4. Check interval: 1 minute
  5. Expected response:
    • Status code: 200
    • Response body contains: "status":"ok"
    • Response time alert threshold: 3000ms
  6. Save the monitor

If you have a custom domain with Azure Front Door or Azure Application Gateway, monitor the production hostname too:

https://api.yourdomain.com/health

This catches routing failures at the Azure Front Door or Application Gateway layer that won't show up when monitoring the .azurewebsites.net URL directly.

Setting Up SSL Certificate Monitoring

Azure App Service provides managed TLS certificates, but they can fail to renew. Add a second monitor targeting your production domain — Vigilmon automatically monitors the TLS certificate and alerts you before it expires.

Step 3: Monitor Azure Functions

Azure Functions present a different challenge. HTTP-triggered functions are easy to monitor — treat them like any other HTTP endpoint. But timer-triggered functions (the equivalent of CronJobs) are invisible to uptime monitors unless they actively report in.

HTTP-Triggered Functions

// HealthFunction.cs
[FunctionName("Health")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "health")] HttpRequest req,
    ILogger log)
{
    var health = new
    {
        status = "ok",
        function_app = Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME"),
        region = Environment.GetEnvironmentVariable("REGION_NAME"),
        timestamp = DateTimeOffset.UtcNow
    };

    return new OkObjectResult(health);
}

Add a Vigilmon HTTP monitor targeting: https://your-function-app.azurewebsites.net/api/health

Timer-Triggered Functions (Heartbeat Monitoring)

  1. In Vigilmon, go to Monitors → New Monitor → Heartbeat
  2. Set the name: azure-data-sync-timer
  3. Set the expected interval matching your timer schedule (e.g., 1 day for a daily job)
  4. Set the grace period: 30 minutes
  5. Save — copy the unique ping URL

Wire the ping into your timer function:

[FunctionName("DailyDataSync")]
public static async Task Run(
    [TimerTrigger("0 0 2 * * *")] TimerInfo myTimer,
    ILogger log)
{
    log.LogInformation("DailyDataSync started at: {time}", DateTime.Now);

    try
    {
        await RunSyncLogic();

        // Ping Vigilmon on success
        var heartbeatUrl = Environment.GetEnvironmentVariable("VIGILMON_HEARTBEAT_URL");
        using var http = new HttpClient();
        await http.GetAsync(heartbeatUrl);

        log.LogInformation("DailyDataSync completed successfully");
    }
    catch (Exception ex)
    {
        log.LogError(ex, "DailyDataSync failed — heartbeat not sent");
        throw; // Let Azure Functions handle the retry
    }
}

Add VIGILMON_HEARTBEAT_URL to your Function App's Application Settings (or Key Vault reference).

Step 4: Multi-Region Monitoring for Global Azure Deployments

If you run in multiple Azure regions for latency or redundancy, each regional endpoint needs its own monitor:

| Monitor Name | URL | Region | |---|---|---| | [eastus] API health | https://api-eastus.yourdomain.com/health | East US | | [westeurope] API health | https://api-westeurope.yourdomain.com/health | West Europe | | [southeastasia] API health | https://api-sea.yourdomain.com/health | Southeast Asia | | [global] Azure Front Door | https://api.yourdomain.com/health | Global |

Create a Status Page in Vigilmon grouping all regional endpoints — you'll see at a glance whether an incident is regional or global.

Step 5: Webhook Integration With Azure Logic Apps

When Vigilmon detects downtime, you can trigger automated Azure remediation using Logic Apps.

Create the Logic App

  1. In Azure Portal, create a new Logic App (Consumption)
  2. Use the "When an HTTP request is received" trigger
  3. Copy the generated webhook URL
  4. Add actions: send a Teams notification, create an Azure DevOps work item, or trigger an App Service restart

Register the Webhook in Vigilmon

  1. Go to Alert Channels → New Channel → Webhook
  2. Paste your Logic App HTTP trigger URL
  3. Assign it to your Azure monitors

The payload Vigilmon sends:

{
  "monitor_name": "[eastus] API health",
  "status": "down",
  "url": "https://api-eastus.yourdomain.com/health",
  "started_at": "2026-06-30T10:23:00Z",
  "duration_seconds": 45,
  "regions_failing": ["us-east", "eu-west"]
}

Your Logic App can parse this JSON and make decisions: if regions_failing contains only one region, page the on-call engineer. If all regions are failing, trigger an App Service restart and escalate to the incident channel.

Azure API Management Monitoring

If you expose APIs through Azure API Management, add a monitor for the APIM gateway endpoint, not just the backend App Service:

https://your-apim.azure-api.net/api/health

Failures at the APIM layer (quota exhaustion, policy errors, certificate issues) won't appear in App Service logs. A Vigilmon monitor on the gateway gives you the full end-to-end coverage.

Summary

| Azure Service | Monitoring Approach | What It Catches | |---|---|---| | App Service | Vigilmon HTTP on /health | App crashes, deployment failures, routing issues | | Custom domain | Vigilmon HTTP + TLS monitoring | Front Door / App Gateway failures, cert expiry | | HTTP Functions | Vigilmon HTTP | Cold start failures, dependency errors | | Timer Functions | Vigilmon heartbeat | Missed schedules, silent failures | | API Management | Vigilmon HTTP on APIM endpoint | Policy errors, quota limits, gateway outages | | Multi-region | One monitor per region + status page | Regional incidents vs global outages |

Application Insights is the right tool for tracing, profiling, and deep diagnostics. Vigilmon is the right tool for knowing your Azure services are reachable right now, before your users tell you they aren't.

Start monitoring your Azure services at vigilmon.online — free tier, no credit card, monitors live in under two minutes.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles