playbooks

home / skills / github / awesome-copilot / appinsights-instrumentation

appinsights-instrumentation skill

/skills/appinsights-instrumentation

This skill guides you to instrument a web app with Azure App Insights for comprehensive telemetry and improved observability.

npx playbooks add skill github/awesome-copilot --skill appinsights-instrumentation

Review the files below or copy the command above to add this skill to your agents.

Files (8)
SKILL.md
2.4 KB
---
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](references/AUTO.md) 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](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](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](references/ASPNETCORE.md) for how to modify the C# code.
- If the app is a Node.js app, see [NODEJS guide](references/NODEJS.md) for how to modify the JavaScript/TypeScript code.
- If the app is a Python app, see [PYTHON guide](references/PYTHON.md) for how to modify the Python code.

Overview

This skill instruments a webapp to send useful telemetry to Azure Application Insights, improving observability and troubleshooting. It guides detection of app type and hosting, recommends automatic instrumentation when available, and provides steps for manual resource creation and code changes for ASP.NET Core and Node.js apps.

How this skill works

The skill inspects the workspace to identify the programming language, framework, and hosting environment and then recommends the right instrumentation path. It prefers auto-instrumentation for supported scenarios (for example, ASP.NET Core on Azure App Service) and otherwise walks through creating an App Insights resource and injecting the SDK or configuration into the app. It always asks the user to confirm hosting details before proceeding.

When to use it

  • You want end-to-end telemetry for a webapp running in Azure or elsewhere.
  • You need to add performance, exception, or request tracking to an existing app.
  • You want to centralize logs, metrics, and traces for debugging and alerts.
  • You are preparing an app for production and need visibility into health and user behavior.
  • You need to instrument a Node.js or ASP.NET Core application for Azure monitoring.

Best practices

  • Detect language, framework, and hosting from source files and confirm any uncertain details with the user.
  • Prefer platform auto-instrumentation when supported to minimize code changes and preserve app behavior.
  • Create the Application Insights resource in the same meaningful resource group as the app to simplify management.
  • Use infrastructure-as-code (Bicep/ARM) or Azure CLI scripts to create consistent, repeatable monitoring resources.
  • Add only the telemetry you need initially, then expand to custom events and metrics to avoid noise and cost increases.

Example use cases

  • Add Application Insights to an ASP.NET Core webapp deployed to Azure App Service using auto-instrumentation.
  • Manually instrument a Node.js Express app to report requests, exceptions, and custom events to App Insights.
  • Create an App Insights resource alongside existing infrastructure via Bicep or Azure CLI and wire the connection string into the app configuration.
  • Instrument a containerized webapp by adding the SDK and environment configuration to the container image or runtime.

FAQ

Which app types are supported?

This skill is focused on ASP.NET Core and Node.js webapps. It also includes guidance for Python apps where applicable.

When should I choose auto-instrumentation vs manual?

Use auto-instrumentation when your hosting platform supports it (reduces code changes). Choose manual when auto-instrumentation is not available or you need fine-grained custom telemetry.

Where should I create the App Insights resource?

Create it in a resource group that logically groups the app’s resources—ideally the same resource group that contains the app to simplify permissions and billing.