← Back to DevBytes
Developer Tutorial July 18, 2026 10 min read

Monitoring Logic Apps: Metrics, Alarms, and Dashboards

Understanding Logic Apps Monitoring

Monitoring Logic Apps is the systematic process of collecting, analyzing, and acting on telemetry data generated by your workflow executions. Azure Logic Apps—whether running in the multi-tenant Consumption tier or the single-tenant Standard tier—emit a rich stream of operational data through Azure Monitor, including run statuses, trigger histories, action-level metrics, and diagnostic logs. Effective monitoring means you transform this raw data into actionable visibility: you know within seconds when a workflow fails, you understand why it failed, and you can spot performance degradation before your downstream systems or customers feel the impact.

In practice, monitoring Logic Apps involves three interconnected pillars: metrics (numerical time-series data like run count and latency), alarms (automated notifications or actions triggered by thresholds), and dashboards (visual canvases that consolidate metrics and logs into a single pane of glass). Together, these pillars form the backbone of operational reliability for any integration workload running on Azure Logic Apps.

Why Monitoring Matters for Logic Apps

Logic Apps sit at the center of many mission-critical integration pipelines—orchestrating ETL jobs, processing orders, syncing identity data, or fanning out approval workflows. When a Logic App silently fails or runs slower than expected, the consequences cascade quickly: stuck orders, missed SLAs, data inconsistencies, and frustrated users. Monitoring gives you early detection and rapid diagnosis. Specifically, it helps you:

Without monitoring, you're operating blind. With it, you turn your Logic Apps into a well-lit, observable component of your architecture.

Key Metrics and Diagnostic Logs

Platform Metrics (Azure Monitor)

Azure Logic Apps automatically surfaces a set of platform metrics in Azure Monitor with no extra configuration. These metrics are available in near real-time (sampled every few minutes) and retained for 93 days. The most critical ones are:

You can query these metrics via the Azure Portal Metrics Explorer, Azure Monitor REST API, or CLI. Here's an example using Azure CLI to fetch the Runs Failed metric for a specific Logic App over the last hour:

az monitor metrics list \
  --resource "/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.Logic/workflows/{logic-app-name}" \
  --metric "RunsFailed" \
  --interval PT5M \
  --start-time "$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ)" \
  --end-time "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
  --aggregation "Total" \
  --output table

Diagnostic Logs (Log Analytics)

Platform metrics tell you that something happened. Diagnostic logs tell you what exactly happened. When you enable diagnostic settings on your Logic App, Azure streams detailed execution data to a Log Analytics workspace, Storage Account, or Event Hub. The key log categories are:

Enable diagnostic settings via an ARM template or CLI. Here's a CLI snippet that sends all logic app diagnostics to a Log Analytics workspace:

WORKSPACE_ID=$(az monitor log-analytics workspace show \
  --resource-group "{rg}" \
  --workspace-name "{workspace-name}" \
  --query id -o tsv)

LOGIC_APP_ID=$(az logic workflow show \
  --resource-group "{rg}" \
  --name "{logic-app-name}" \
  --query id -o tsv)

az monitor diagnostic-settings create \
  --resource "$LOGIC_APP_ID" \
  --name "send-to-log-analytics" \
  --workspace "$WORKSPACE_ID" \
  --logs '[{
    "category": "WorkflowRuntime",
    "enabled": true,
    "retentionPolicy": {"enabled": false, "days": 0}
  },
  {
    "category": "TriggerHistory",
    "enabled": true,
    "retentionPolicy": {"enabled": false, "days": 0}
  }]' \
  --metrics '[{
    "category": "AllMetrics",
    "enabled": true,
    "retentionPolicy": {"enabled": false, "days": 0}
  }]'

Once logs flow into Log Analytics, you unlock powerful Kusto Query Language (KQL) queries. For example, to find all failed actions across all runs in the last 24 hours with their error messages:

AzureDiagnostics
| where TimeGenerated > ago(24h)
| where ResourceType == "WORKFLOWS"
| where OperationName == "ActionCompleted"
| where Status == "Failed"
| project TimeGenerated, 
          WorkflowName = resource_workflowName,
          ActionName = actionName,
          ErrorCode = code, 
          ErrorMessage = errorMessage
| order by TimeGenerated desc

Another practical query: identify which actions contribute most to overall run latency, helping you target optimization efforts:

AzureDiagnostics
| where OperationName == "ActionCompleted"
| where Status == "Succeeded"
| summarize AvgDurationSeconds = avg(durationInMs / 1000), 
            P95DurationSeconds = percentile(durationInMs / 1000, 95),
            ExecutionCount = count() 
            by ActionName = actionName
| order by AvgDurationSeconds desc

Building Alarms That Actually Work

Alert Types and Strategy

Azure Monitor supports several alert types relevant to Logic Apps: metric alerts (fast, cheap, great for volume and failure-rate signals), log search alerts (powerful, flexible, KQL-based), and activity log alerts (for control-plane changes like someone deleting a workflow). A robust alarm strategy layers these together.

Start with a metric alert on Runs Failed—this is your catch-all failure detector. Then add log search alerts for nuanced conditions that metrics alone cannot express, such as "alert if any action within a specific workflow fails with HTTP 5xx more than 3 times in 10 minutes." Finally, configure activity log alerts to notify you when workflows are modified or deleted unexpectedly.

Creating a Metric Alert via Azure CLI

Here's a complete example that creates a metric alert firing when any Logic App in a resource group experiences more than 5 failed runs in a 5-minute window:

# Define the scope to the resource group containing your Logic Apps
SCOPE="/subscriptions/{sub-id}/resourceGroups/{rg}"

# Create the alert rule
az monitor metrics alert create \
  --name "High-Failure-Rate-LogicApps" \
  --resource-group "{rg}" \
  --scopes "$SCOPE" \
  --condition "total Runs Failed >= 5 in 5min" \
  --description "Alert when Logic App failures exceed 5 in a rolling 5-minute window" \
  --severity 2 \
  --evaluation-frequency 5m \
  --window-size 5m \
  --action "/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.Insights/actionGroups/{action-group-name}"

For the action group referenced above, create it first to define where notifications go—email, SMS, webhook, or ITSM integration:

az monitor action-group create \
  --name "oncall-team" \
  --resource-group "{rg}" \
  --action email ops-team-email ops@contoso.com \
  --action webhook pagerduty-hook "https://events.pagerduty.com/v2/enqueue"

Creating a Log Search Alert

Log search alerts shine when you need to query structured diagnostic data. For instance, alert specifically on HTTP 503 errors coming from the "CallExternalAPI" action—something a generic metric alert cannot filter:

# First, create the log search alert condition as JSON
az monitor log-search alert create \
  --name "ExternalAPI-503-Detector" \
  --resource-group "{rg}" \
  --scope "/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.Logic/workflows/{logic-app-name}" \
  --condition 'AzureDiagnostics
    | where OperationName == "ActionCompleted"
    | where actionName == "CallExternalAPI"
    | where code == "503"
    | where TimeGenerated > ago(10m)
    | summarize count() by bin(TimeGenerated, 1m)
    | where count_ > 3' \
  --window-size 10m \
  --frequency 5m \
  --severity 1 \
  --action-group "/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.Insights/actionGroups/oncall-team" \
  --description "Alert when CallExternalAPI action returns 503 more than 3 times in 10 minutes"

Dynamic Thresholds for Smart Alerts

Instead of hardcoding "greater than 5 failures," consider dynamic thresholds—Azure learns the historical pattern of your metric and alerts on deviations. This works well for metrics like Run Latency, where "normal" varies by time of day or day of week:

az monitor metrics alert create \
  --name "RunLatency-Anomaly" \
  --resource-group "{rg}" \
  --scopes "/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.Logic/workflows/{logic-app-name}" \
  --condition "average Run Latency dynamic threshold" \
  --dynamic-threshold-sensitivity "Medium" \
  --dynamic-threshold-failing-periods 3 \
  --dynamic-threshold-trigger "ConsecutiveBreach" \
  --evaluation-frequency 15m \
  --window-size 15m \
  --severity 3 \
  --action "/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.Insights/actionGroups/oncall-team"

Designing Dashboards for Logic Apps Observability

Azure Monitor Workbooks

Workbooks are the most powerful dashboarding tool for Logic Apps. They combine metrics charts, KQL queries, markdown text, and interactive parameters into a single rich report. You can create a workbook that shows: a summary tile of success/failure counts, a time-series chart of run latency, a table of recent failures with error details, and a heatmap of action-level performance—all in one view.

Here's a workbook KQL query you can embed in a workbook to create a "Recent Failures" table with drill-down capability:

AzureDiagnostics
| where ResourceType == "WORKFLOWS"
| where OperationName == "WorkflowRunCompleted"
| where Status == "Failed"
| project TimeGenerated,
          WorkflowName = resource_workflowName,
          RunName = runName,
          ErrorCode = code,
          ErrorMessage = errorMessage
| order by TimeGenerated desc
| take 50

To build a "Success Rate Over Time" chart in a workbook, use this query that bins results by hour and calculates the success percentage:

AzureDiagnostics
| where ResourceType == "WORKFLOWS"
| where OperationName == "WorkflowRunCompleted"
| summarize TotalRuns = count(),
            FailedRuns = countif(Status == "Failed")
            by bin(TimeGenerated, 1h)
| extend SuccessRate = round((1 - (FailedRuns * 1.0 / TotalRuns)) * 100, 2)
| project TimeGenerated, SuccessRate, TotalRuns, FailedRuns
| render timechart

Custom Azure Dashboards with Pinned Tiles

For a quick, always-on overview, you can pin individual metric charts to a custom Azure Dashboard. Navigate to your Logic App's Metrics page in the portal, configure the chart (e.g., "Runs Failed" as a bar chart with a 7-day timeframe), and click "Pin to dashboard." Do this for each critical metric—Run Latency, Actions Failed, Trigger Latency—and arrange the tiles into a logical layout. These dashboards are shared across your team and update automatically.

Embedded Monitoring with Application Insights (Standard Tier)

For Logic Apps running in the Standard tier (which runs on Azure Functions infrastructure), you can optionally enable Application Insights for deeper telemetry. This gives you distributed tracing across workflow actions, performance profiles, and intelligent anomaly detection. Enable it by adding the APPINSIGHTS_INSTRUMENTATIONKEY application setting and including the Application Insights connector in your workflow definition:

{
  "definition": {
    "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
    "actions": {
      "TrackCustomEvent": {
        "type": "ApplicationInsights",
        "inputs": {
          "name": "TrackEvent",
          "properties": {
            "eventName": "OrderProcessed",
            "dimensions": {
              "orderId": "@{triggerBody().orderId}",
              "status": "@{action('ProcessOrder').outputs.statusCode}"
            }
          }
        }
      }
    }
  }
}

This approach lets you build dashboards in Application Insights that correlate Logic App performance with the rest of your application stack—APIs, databases, and external services all in one view.

Best Practices for Logic Apps Monitoring

Conclusion

Monitoring Logic Apps is not a one-time setup task—it is an operational practice that matures alongside your integrations. By combining Azure Monitor metrics for rapid failure detection, diagnostic logs for deep forensic analysis, and thoughtfully designed alerts and dashboards, you build an observability layer that keeps your workflows healthy, your costs predictable, and your team confident. Start small: enable diagnostic settings, create one critical failure alert, and pin a few key metric charts to a dashboard. From there, iterate by adding dynamic thresholds, log-search alerts for nuanced conditions, and workbooks that give your entire team shared visibility. The result is a Logic Apps environment that is not just running, but truly observable—and ready to support the business processes that depend on it.

🚀 Need a reliable AI agent for your project?

Deploy Hermes Agent in 10 minutes. Managed hosting, zero DevOps.

Get Started — $23.99/mo
← Back to all articles