Azure Application Insights Instrumentation Guide
Practical guidance for adding Application Insights telemetry to Azure-hosted ASP.NET Core and Node.js web apps.
The skill clearly separates reference guidance from actual project modification, requires confirmation of unknown hosting context, and recommends secretref for Container Apps. These support basic scoping and least-privilege awareness. Points are deducted because it does not systematically address sensitive telemetry, data flow, permission scope, confirmation points, or rollback, and some environment-variable and Azure CLI procedures could expose connection strings.
The main flow and the ASP.NET Core, Node.js, Python, and Container Apps references are reasonably structured and include some configuration warnings. Points are deducted because the prerequisites list only ASP.NET Core and Node.js while the references also cover Python, Java, and containers; several instructions depend on scripts/appinsights.ps1 not present in the supplied evidence; the Java example uses a deprecated beta exporter; and no skill-specific tests or reproducible failure feedback are provided.
Trigger phrases, intended use, and handoff to azure-prepare are stated clearly, and the material covers several languages and Azure hosting models. Points are deducted for the mismatch between declared prerequisites and actual coverage, limited non-fit boundaries for non-Azure or unsupported hosting, insufficient production data-governance guidance, and no Chinese-language or mainland-China reachability guidance.
The documentation has a useful progressive structure with metadata, version 1.1.2, MIT licensing, installation snippets, platform references, and some limitation notes; the repository also supplies general testing, licensing, and security-policy material. Points are deducted for the lack of a skill-specific changelog, explicit maintenance owner and update path, FAQ, dependency-version policy, and complete troubleshooting; referenced external materials and scripts are incomplete in the supplied evidence.
The material is directly useful for understanding Application Insights, selecting basic SDK initialization patterns, and configuring a connection string, with reusable commands and code. Points are deducted because static review cannot verify outcomes; Python, Java, and some platform scenarios are incomplete, and the skill lacks end-to-end steps for sensitive-field filtering, sampling, permissions, and verifying telemetry delivery, leaving substantial judgment to the user.
The skill contains code, CLI commands, KQL queries, and one Microsoft Learn link, while the repository shows general CI and test infrastructure. Points are deducted because no acceptance criteria, dedicated tests, or third-party execution evidence for this skill path are supplied; repository-level evidence does not independently reproduce this skill's key paths, so only limited auditability is justified.
- Check the actual language, framework, and hosting model before use; the documented prerequisites and coverage do not fully match.
- Do not place the Application Insights connection string in source, logs, or public command output; add telemetry redaction, permission, sampling, and rollback guidance.
- Verify that the referenced appinsights.ps1, SDK versions, and Java migration path exist and remain supported, then confirm telemetry delivery after deployment.
- Azure Portal, Azure CLI, and external documentation require network access and account permissions; mainland-China reachability and alternatives are not documented.
What does this skill do, and when should you use it?
This is a reference-oriented Agent Skill for Azure Application Insights instrumentation. It helps an agent identify an application's language, framework, and hosting model, then choose an automatic or manual instrumentation path. The material covers ASP.NET Core, Node.js, Python, OpenTelemetry, and observability guidance for Azure Container Apps. It is best suited to developers seeking setup guidance and patterns, while project changes are delegated to azure-prepare.
Reads workspace source code to infer the application's language, framework, and hosting model; recommends automatic or manual instrumentation; points to guides for ASP.NET Core, Node.js, Python, automatic instrumentation, Container Apps, and OpenTelemetry SDKs; provides references for adding Application Insights to Bicep or creating the resource with Azure CLI; and recommends using a meaningful resource group, preferably the one containing the hosted application's Azure resources.
- An ASP.NET Core developer on Azure App Service who wants guidance on automatic instrumentation.
- A Node.js developer hosting a web application in Azure who needs SDK setup instructions and telemetry patterns.
- An engineer researching how to create an Application Insights resource and update an existing application's code.
- A developer comparing Python or TypeScript OpenTelemetry distro and exporter references for Azure monitoring.
- A team running an application on Azure Container Apps that needs observability guidance.
What are this skill's strengths and limitations?
- Covers SDK setup, telemetry patterns, automatic instrumentation, and manual instrumentation references.
- Includes related OpenTelemetry references for ASP.NET Core, Node.js, Python, TypeScript, and Java.
- Clearly distinguishes reference guidance from the workflow for changing a project.
- Microsoft-authored metadata identifies version 1.1.2 and MIT licensing.
- The explicit prerequisites list only Azure-hosted ASP.NET Core and Node.js applications, leaving the broader scope less clear.
- The resource-creation and code-modification paths depend on repository reference files and scripts not included in the prompt.
- The source does not provide test-coverage results for this individual skill.
- It is not the component-adding tool; project changes should be handled by azure-prepare.
How do you install this skill?
Install the collection with npx skills add microsoft/skills, then select the required skills in the wizard; skills are installed to the selected agent's directory, such as .github/skills/ for GitHub Copilot. In Copilot CLI, the README also documents /plugin marketplace add microsoft/skills followed by /plugin install azure-skills@skills. The source does not document a direct command for installing only this individual skill.
How do you use this skill?
Example prompts include How do I instrument my ASP.NET Core app with Application Insights? and Show me App Insights SDK telemetry patterns. If the request is to add or modify components, use azure-prepare instead, and always establish where the application is hosted.
How does this skill compare with similar options?
The source explicitly contrasts this skill with azure-prepare: this skill supplies guidance, patterns, and references, while azure-prepare handles adding or modifying components.