appinsights-instrumentation
github/awesome-copilot
Instrument webapps to send telemetry data to Azure App Insights for observability.
What is appinsights-instrumentation?
This skill enables sending telemetry data from a webapp to Azure App Insights for monitoring application health and performance. Use it when you need observability into your ASP.NET Core or Node.js application running on Azure.
- Auto-instrument ASP.NET Core apps hosted in Azure App Service
- Manually instrument ASP.NET Core, Node.js, and Python applications
- Create Azure App Insights resources via Bicep templates or Azure CLI
- Collect and send telemetry data for application health monitoring
- Configure connection strings and instrumentation keys in application code
How to install appinsights-instrumentation
npx skills add https://github.com/github/awesome-copilot --skill appinsights-instrumentation- ASP.NET Core app hosted in Azure, or Node.js app hosted in Azure
- Azure subscription with permissions to create App Insights resources
- Existing Bicep templates (optional, for infrastructure-as-code approach) or Azure CLI access
How to use appinsights-instrumentation
- 1.Identify your application type (ASP.NET Core, Node.js, or Python) and hosting environment
- 2.For ASP.NET Core on Azure App Service, use the AUTO guide for automatic instrumentation
- 3.For manual instrumentation, create an App Insights resource using Bicep templates or Azure CLI
- 4.Update your application code with the appropriate instrumentation SDK (ASPNETCORE, NODEJS, or PYTHON guide)
- 5.Configure the connection string or instrumentation key in your application settings
- 6.Deploy the updated application and verify telemetry data is flowing to App Insights
Use cases
- Monitor application performance and health metrics in production
- Track request failures and exceptions in real-time
- Debug performance issues by analyzing telemetry data
- Set up alerts based on application health thresholds
- Correlate logs and traces across distributed application components
- Backend developers working with ASP.NET Core or Node.js
- DevOps engineers setting up application monitoring
- Teams deploying applications to Azure
- Developers needing observability into webapp behavior
appinsights-instrumentation FAQ
ASP.NET Core and Node.js apps hosted on Azure are fully supported. Python apps can also be instrumented manually.
Auto-instrumentation is available for C# ASP.NET Core apps hosted in Azure App Service. Other configurations require manual instrumentation.
You can add App Insights to an existing Bicep template or use Azure CLI commands provided in the skill's scripts.
The skill collects application health metrics, request data, exceptions, and performance information sent to Azure App Insights.
Yes, you need to add the App Insights SDK and configure the connection string in your application code.
Full instructions (SKILL.md)
Source of truth, from github/awesome-copilot.
name: appinsights-instrumentation description: 'Instrument a webapp to send useful telemetry data to Azure App Insights'
AppInsights instrumentation
This skill enables sending telemetry data of a webapp to Azure App Insights for better observability of the app's health.
When to use this skill
Use this skill when the user wants to enable telemetry for their webapp.
Prerequisites
The app in the workspace must be one of these kinds
- An ASP.NET Core app hosted in Azure
- A Node.js app hosted in Azure
Guidelines
Collect context information
Find out the (programming language, application framework, hosting) tuple of the application the user is trying to add telemetry support in. This determines how the application can be instrumented. Read the source code to make an educated guess. Confirm with the user on anything you don't know. You must always ask the user where the application is hosted (e.g. on a personal computer, in an Azure App Service as code, in an Azure App Service as container, in an Azure Container App, etc.).
Prefer auto-instrument if possible
If the app is a C# ASP.NET Core app hosted in Azure App Service, use AUTO guide to help user auto-instrument the app.
Manually instrument
Manually instrument the app by creating the AppInsights resource and update the app's code.
Create AppInsights resource
Use one of the following options that fits the environment.
- Add AppInsights to existing Bicep template. See examples/appinsights.bicep for what to add. This is the best option if there are existing Bicep template files in the workspace.
- Use Azure CLI. See scripts/appinsights.ps1 for what Azure CLI command to execute to create the App Insights resource.
No matter which option you choose, recommend the user to create the App Insights resource in a meaningful resource group that makes managing resources easier. A good candidate will be the same resource group that contains the resources for the hosted app in Azure.
Modify application code
- If the app is an ASP.NET Core app, see ASPNETCORE guide for how to modify the C# code.
- If the app is a Node.js app, see NODEJS guide for how to modify the JavaScript/TypeScript code.
- If the app is a Python app, see PYTHON guide for how to modify the Python code.
Related skills
More from github/awesome-copilot and the wider catalog.
apple-appstore-reviewer
Audit iOS apps for Apple App Store compliance and rejection risks.
arch-linux-triage
Structured Arch Linux troubleshooting with pacman, systemd, and journalctl-based remediation steps.
architecture-blueprint-generator
Analyze codebases and generate comprehensive architectural documentation with diagrams and patterns.
arize-ai-provider-integration
Creates, reads, updates, and deletes Arize AI integrations that store LLM provider credentials used by evaluators and other Arize features. Supports any LLM provider (e.g. OpenAI, Anthropic, Azure OpenAI, AWS Bedrock, Vertex AI, Gemini, NVIDIA NIM). Use when the user mentions AI integration, LLM provider credentials, create integration, list integrations, update credentials, delete integration, or connecting an LLM provider to Arize.
arize-evaluator
Handles LLM-as-judge evaluation workflows on Arize including creating/updating evaluators, running evaluations on spans or experiments, managing tasks, trigger-run operations, column mapping, and continuous monitoring. Use when the user mentions create evaluator, LLM judge, hallucination, faithfulness, correctness, relevance, run eval, score spans, score experiment, trigger-run, column mapping, continuous monitoring, or improve evaluator prompt.
arize-instrumentation
Adds Arize AX tracing to an LLM application for the first time. Follows a two-phase agent-assisted flow to analyze the codebase then implement instrumentation after user confirmation. Use when the user wants to instrument their app, add tracing from scratch, set up LLM observability, integrate OpenTelemetry or openinference, or get started with Arize tracing.