azure-observability-workflows

Name: azure-observability-workflows
Author: composio-community

github.com/composio-communityCloud & DevOps1443 installsUpdated 23w ago

About azure-observability-workflows

A Claude skill for planning and implementing observability for applications on Microsoft Azure. It guides teams through telemetry, tracing, centralized monitoring, dashboards, and actionable alerts for production systems.

Key features

01Azure observability planning
02Centralized logs and metrics
03Distributed tracing setup
04Monitoring dashboards and alerts
05Production telemetry validation

Use cases

01Monitor Azure applications in production
02Trace requests across microservices
03Diagnose incidents and bottlenecks

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/composio-community/opencode-skills --skill azure-observability-workflows

After installing, type/azure-observability-workflowsin Claude Code to confirm it loaded.

Details

From the project README

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

Comments

Markdown supported

Details

Author: composio-community
Repository: composio-community/opencode-skills
Category: Cloud & DevOps
Installs: 43
GitHub stars: 14

Report

More skills

All skills

lark-apps

open.feishu.cn

732.0k

Develop and host Miaoda (Spark/Miaoda) apps: app creation, local full-stack development, cloud generation and iteration, creative design (UI mockups / interactive prototypes / wireframes / landing pages / dashboards / slide decks / visual exploration), integration of AI-related capabilities, Feishu platform capabilities, or other external capabilities; log/Trace/monitoring metric/PV/UV queries; environment variable management; app collaborators and collaboration permissions; app roles and members; and automation triggers (scheduled / record changes / Webhook / Feishu approvals). Use when users want to develop or create a system, tool, platform, or app; develop locally or in the cloud, modify, deploy, publish, launch, or get a shareable link; create a page or website with HTML and deploy it to Miaoda; design, create a mockup, prototype, wireframe, PPT, deck, or visual exploration; or mention Miaoda/Spark/Miaoda apps (links like `/app/app_xxx` or `/page/<token>`, runtime domains like *.aiforce.cloud), app databases, app file storage, open API Keys, visibility, app collaborators/developer permissions, app roles/role members, production logs, API request volume, error volume, latency, traffic, environment variables, or setting up automation tasks, scheduled triggers, or approval-triggered automation for Miaoda apps. Not for regular cloud drive file uploads (lark-drive), Feishu document editing (lark-doc), or native slide creation (lark-slides).

azure-prepare

github.com/microsoft

571.7k

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.

wizard

github.com/mattpocock

571.5k

Generate an interactive bash wizard that walks a human through steps only they can perform. Use when provisioning infrastructure, setting up credentials or CI secrets, walking an unfamiliar third-party dashboard, or running a one-off migration or cutover. Don't invoke this for steps the agent can perform itself.

azure-ai

github.com/microsoft

571.2k

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.