azure-observability-workflows
Workflow for implementing observability systems on Microsoft Azure using logging, monitoring, tracing, telemetry, metrics, dashboards, and production-grade cloud diagnostics.
- Installs
- 42
- Last 24h
- —
- Trending rank
- —
- Security
- Not audited
Install
Works with every agent the skills CLI supports.
npx skills add https://github.com/composio-community/opencode-skills --skill azure-observability-workflows- 01
Install
Run the command in your project. The CLI asks which agents to install for.
- 02
Describe the task
Ask your agent for something this skill covers. It loads azure-observability-workflows automatically when relevant.
- 03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.
SKILL.md
The instructions your agent reads when the skill is triggered.
Azure Observability Workflows
Overview
This skill enables Claude to design and implement observability systems for applications running on Microsoft Azure.
The workflow focuses on:
- distributed tracing
- centralized logging
- metrics collection
- cloud monitoring
- telemetry pipelines
- incident diagnostics
- alerting systems
- production visibility
The goal is to make cloud systems:
- observable
- debuggable
- measurable
- reliable
- production-ready
Instead of reacting to failures after they happen, observability systems should proactively surface:
- bottlenecks
- errors
- degraded performance
- unusual system behavior
- infrastructure instability
This workflow prioritizes operational visibility and debugging quality across distributed systems.
Setup
Before starting:
-
Create an Azure account: https://azure.microsoft.com
-
Install Azure CLI:
az login
- Enable Azure monitoring services.
Recommended Azure services:
- Azure Monitor
- Application Insights
- Log Analytics
- Azure Dashboard
- Azure Alerts
Recommended tools:
- VS Code
- Azure Portal
- Grafana
- OpenTelemetry
- Docker
- Kubernetes (optional)
Optional:
- Prometheus
- Jaeger
- Azure Managed Grafana
- Distributed tracing systems
Inputs Required
- Application architecture
- Cloud infrastructure
- Deployment environment
- Service dependencies
- Monitoring objectives
Optional:
- Existing telemetry systems
- Logging pipelines
- Kubernetes clusters
- Incident history
When to Use This Skill
Use this skill when:
- deploying production applications
- debugging distributed systems
- monitoring cloud infrastructure
- tracking application performance
- diagnosing incidents
- implementing SRE workflows
- scaling microservices
- improving operational reliability
When NOT to Use
Do NOT use this skill for:
- disposable prototypes
- tiny local-only applications
- systems with no production requirements
- workflows without operational monitoring needs
Example Use Case
Build observability infrastructure for a distributed Azure microservices platform.
Claude should:
- Configure telemetry pipelines
- Enable distributed tracing
- Centralize logs
- Create monitoring dashboards
- Configure alerts
- Track infrastructure health
- Diagnose failures proactively
Final result should:
- improve debugging speed
- surface production issues quickly
- increase operational visibility
- support scalable cloud monitoring
- improve reliability and uptime
Core Observability Principles
1. Logs Alone Are Not Enough
Modern observability requires:
- logs
- metrics
- traces
- telemetry
- distributed context
Claude should combine:
- application logs
- infrastructure metrics
- request traces
- dependency monitoring
Good observability systems provide:
- visibility
- diagnostics
- operational understanding
2. Distributed Systems Require Distributed Tracing
Microservices introduce:
- request chains
- async communication
- hidden bottlenecks
- cross-service failures
Claude should implement:
- trace correlation
- request IDs
- distributed spans
- dependency tracking
Distributed tracing improves:
- debugging speed
- bottleneck detection
- root-cause analysis
3. Centralize Monitoring
Observability data should remain centralized.
Recommended systems:
- Azure Monitor
- Application Insights
- Log Analytics
- Grafana dashboards
Centralization improves:
- debugging
- incident response
- operational visibility
Avoid:
- fragmented logging systems
- isolated metrics
- disconnected dashboards
4. Monitor What Matters
Not all metrics are equally valuable.
Claude should prioritize:
- latency
- error rates
- throughput
- resource utilization
- request failures
- dependency health
Avoid:
- noisy dashboards
- vanity metrics
- excessive telemetry without purpose
Good monitoring improves:
- reliability
- scaling decisions
- incident detection
5. Alerts Should Be Actionable
Bad alerting systems create:
- alert fatigue
- ignored notifications
- operational chaos
Claude should configure alerts for:
- real incidents
- meaningful thresholds
- actionable failures
- production-impacting issues
Good alerts improve:
- operational response
- uptime
- debugging speed
Workflow
1. Analyze System Architecture
Start by identifying:
- services
- APIs
- databases
- queues
- infrastructure dependencies
Determine:
- critical workflows
- failure points
- performance bottlenecks
- observability gaps
Understand:
- request flow
- service boundaries
- scaling behavior
2. Configure Telemetry Collection
Enable:
- application logging
- infrastructure metrics
- distributed traces
- dependency monitoring
Use:
- Application Insights
- Azure Monitor
- OpenTelemetry
Validate:
- telemetry consistency
- trace propagation
- correlation IDs
3. Centralize Logs & Metrics
Route:
- logs
- traces
- metrics
- diagnostics
into centralized systems.
Recommended:
- Log Analytics
- Azure Monitor
- Grafana
Ensure:
- searchable logs
- structured telemetry
- consistent formatting
4. Implement Distributed Tracing
Track:
- requests
- service dependencies
- API calls
- async workflows
Use:
- trace IDs
- span relationships
- request correlation
Distributed tracing improves:
- debugging
- latency analysis
- dependency visibility
5. Create Dashboards
Build dashboards for:
- infrastructure health
- application performance
- error tracking
- queue processing
- API latency
- service dependencies
Dashboards should remain:
- readable
- actionable
- operationally useful
Avoid:
- cluttered dashboards
- excessive graphs
- irrelevant metrics
6. Configure Alerts
Create alerts for:
- service downtime
- latency spikes
- high failure rates
- queue backlogs
- resource exhaustion
Alerts should:
- reduce noise
- remain actionable
- trigger appropriate escalation
7. Validate Production Observability
Before deployment validate:
- logs are searchable
- traces propagate correctly
- metrics update consistently
- alerts trigger correctly
- dashboards remain readable
Ensure:
- incidents can be diagnosed quickly
- telemetry remains reliable
- systems stay observable under load
Output Expectations
The final output should include:
- centralized observability systems
- distributed tracing pipelines
- actionable monitoring dashboards
- production telemetry systems
- scalable diagnostics infrastructure
- cloud-native operational visibility
The workflow itself should remain:
- scalable
- observable
- production-focused
- debugging-friendly
- operationally reliable
Execution Strategy (for AI agents)
The agent should:
- Treat observability as foundational infrastructure
- Centralize telemetry aggressively
- Implement distributed tracing consistently
- Prioritize actionable monitoring
- Reduce alert noise proactively
- Optimize for operational visibility and debugging quality
The workflow should optimize for:
- reliability
- debugging speed
- operational clarity
- incident response quality
- cloud scalability
Best Practices
- Use structured logging consistently
- Implement distributed tracing early
- Centralize metrics and logs
- Monitor latency and error rates closely
- Keep dashboards actionable
- Avoid alert fatigue
- Validate observability under production load
Notes
- Distributed tracing dramatically improves debugging in microservices
- Observability quality strongly affects operational reliability
- Actionable dashboards outperform noisy telemetry systems
- Good alerting reduces operational burnout significantly
- Observability systems should evolve continuously with infrastructure growth
FAQ
What does the azure-observability-workflows skill do?
Workflow for implementing observability systems on Microsoft Azure using logging, monitoring, tracing, telemetry, metrics, dashboards, and production-grade cloud diagnostics.
How do I install azure-observability-workflows?
Run npx skills add https://github.com/composio-community/opencode-skills --skill azure-observability-workflows in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/azure-observability-workflows/ (personal) or .claude/skills/azure-observability-workflows/ (project).
Which AI agents can use azure-observability-workflows?
Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.
Is azure-observability-workflows safe to install?
No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.
Who maintains azure-observability-workflows?
It is published by composio-community in composio-community/opencode-skills. It has 42 recorded installs.
More from composio-community/opencode-skills
frontend-design-systems
composio-community/opencode-skills
Open the skill to read its SKILL.md instructions.
playwright-mcp-workflows
composio-community/opencode-skills
Workflow for using Playwright with MCP-based agent systems to automate browsers, test applications, perform UI validation, and execute reliable end-to-end workflows through structured browser orchestration.
vercel-react-best-practices
composio-community/opencode-skills
Workflow for building production-quality React applications using Vercel-style best practices focused on readability, performance, maintainability, and stable UI behavior.
repo-context-packaging
composio-community/opencode-skills
Open the skill to read its SKILL.md instructions.
multi-agent-orchestration
composio-community/opencode-skills
Split a large task across parallel sub-agents with clean role boundaries and a merge step. Use when the user asks to "parallelize", "use multiple agents", "fan out", or when a task has independent workstreams that bottleneck on one agent.
context-engineering
composio-community/opencode-skills
Workflow for managing, structuring, compressing, and orchestrating context effectively for Claude and AI agent systems to improve reasoning quality, execution consistency, and long-term workflow scalability.
Popular devops & cloud skills
microsoft-foundry
microsoft/azure-skills
Build, deploy, evaluate, optimize, fine-tune, and manage Microsoft Foundry agents, models, and resources end to end. USE FOR: foundry, azd ai agent, azd provision/deploy, hosted agent scaffold/develop/run/deploy/troubleshoot, prompt agent create, managed harness agent create, GitHub Copilot harness agent, create agent, update agent, add tool to agent, invoke agent, agent insights, evaluate agent, batch eval, continuous eval, continuous monitoring, agent CI/CD, optimize prompt, improve prompt, optimize agent instructions, Agent Optimizer scaffold, dataset curation from traces, deploy model, model fine-tuning (SFT/DPO/RFT), Foundry project, RBAC, role assignment, permissions, quota, capacity, region, deployment failure, AI Services, create Foundry resource, knowledge index, customize deployment, onboard, availability, training-data, grader, distillation, large file upload. DO NOT USE FOR: Azure Functions, App Service, general Azure deploy (use azure-deploy), general Azure prep (use azure
azure-diagnostics
microsoft/azure-skills
Debug Azure production issues on Azure using AppLens, Azure Monitor, resource health, and safe triage. WHEN: debug production issues, troubleshoot app service, app service high CPU, app service deployment failure, troubleshoot container apps, container app 503 or target port mismatch, troubleshoot functions, function telemetry missing or stopped after a config/connection-string change, troubleshoot AKS, VM RDP, Linux SSH, VM black screen, can't connect to VM, reset VM password, NSG or firewall blocking, kubectl cannot connect, kube-system/CoreDNS failures, pod pending, crashloop, node not ready, upgrade failures, analyze logs, KQL, insights, image pull failures, cold start issues, health probe failures, resource health, root cause of errors, troubleshoot event hubs, troubleshoot service bus, messaging SDK error, AMQP connection failure, message lock lost, lock renewal during long-running processing, service bus dead letter.
azure-prepare
microsoft/azure-skills
Prepare azd-based Azure projects for deployment: generates azure.yaml, infrastructure (Bicep/Terraform), and Dockerfiles for the Azure Developer CLI (azd) workflow. USE ONLY when the user explicitly wants to use azd as the deployment tool, or the project already has an azure.yaml file. DO NOT USE FOR: non-azd deployments, Python App Service code-only deploys (use python-appservice-deploy), or cross-cloud migration (use azure-cloud-migrate). WHEN: prepare app for azd, create azure.yaml, set up azd infrastructure, modernize app for Azure with azd, deploy with azd, function app, timer trigger, service bus trigger, event-driven function, managed identity, generate Bicep, generate Terraform, create and deploy to Azure.
azure-ai
microsoft/azure-skills
Use for Azure AI: Search, Speech, OpenAI, Document Intelligence. Helps with search, vector/hybrid search, speech-to-text, text-to-speech, transcription, OCR. WHEN: AI Search, query search, vector search, hybrid search, semantic search, speech-to-text, text-to-speech, transcribe, OCR, convert text to speech.
azure-deploy
microsoft/azure-skills
Execute Azure deployments for ALREADY-PREPARED applications that have existing .azure/deployment-plan.md and infrastructure files. DO NOT use this skill when the user asks to CREATE a new application — use azure-prepare instead. This skill runs azd up, azd deploy, terraform apply, and az deployment commands with built-in error recovery. Requires .azure/deployment-plan.md from azure-prepare and validated status from azure-validate. WHEN: "run azd up", "run azd deploy", "execute deployment", "push to production", "push to cloud", "go live", "ship it", "bicep deploy", "terraform apply", "publish to Azure", "launch on Azure". DO NOT USE WHEN: "create and deploy", "build and deploy", "create a new app", "set up infrastructure", "create and deploy to Azure using Terraform" — use azure-prepare for these.
azure-validate
microsoft/azure-skills
Pre-deployment validation for Azure readiness. Run deep checks on configuration, infrastructure (Bicep or Terraform), RBAC role assignments, managed identity permissions, and prerequisites before deploying. WHEN: validate my app, check deployment readiness, run preflight checks, verify configuration, check if ready to deploy, validate azure.yaml, validate Bicep, test before deploying, troubleshoot deployment errors, validate Azure Functions, validate function app, validate serverless deployment, verify RBAC roles, check role assignments, review managed identity permissions, what-if analysis, validate Container Apps deployment.