Skip to main content
skill CX Codex

setup-app-insights — Claude Code skill: Power Apps telemetry

setup-app-insights is a Claude Code skill that configures Application Insights telemetry for Power Apps mobile apps. It can enable, switch, or disable telemetry.

MIT ★ 1,167 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add microsoft/power-platform-skills
/plugin install mobile-app@power-platform-skills
Open on GitHub

What setup-app-insights does

setup-app-insights modifies the app's configuration through app.json → expo.extra.appInsightsConfig. It leaves the data model, connectors and screens untouched—only runtime telemetry settings change. Application Insights is off by default; the skill requires explicit consent.

When enabling or changing resources, the skill discovers workspace-based Application Insights components available to your Azure CLI identity. This matters: only workspace-based components are supported, not classic ones. If no resources exist or access is denied, an administrator can provide the connection string directly.

Invoke it standalone via /setup-app-insights or automatically from /edit-app when the request touches only telemetry. Runs in Claude Code and requires az CLI with Azure login.

What it helps with

  • enable telemetry collection in a Power Apps mobile app
  • switch the Application Insights resource an app uses
  • turn off Application Insights for an app
  • set up usage monitoring for an app

Example prompts for the agent

  • Enable Application Insights for this app
  • Change which Application Insights resource this app sends data to
  • Disable Application Insights on this app

How to install setup-app-insights

1Plugin marketplace

/plugin marketplace add microsoft/power-platform-skills
/plugin install mobile-app@power-platform-skills

This installs the whole mobile-app plugin with all its skills

2Skills CLI (Vercel)

npx skills add microsoft/power-platform-skills --skill setup-app-insights -a claude-code

3Manually: put the files in place

~/.claude/skills/setup-app-insights/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/setup-app-insights/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about setup-app-insights

How do I install setup-app-insights in Claude Code?

Run /plugin marketplace add microsoft/power-platform-skills, then /plugin install mobile-app@power-platform-skills. Alternatively, use npx skills add microsoft/power-platform-skills --skill setup-app-insights -a claude-code.

What does setup-app-insights do?

It enables, changes or disables Application Insights for a Power Apps mobile app. The skill queries Azure CLI for available resources and updates the configuration in app.json.

Which Application Insights resources does it support?

Only workspace-based Application Insights components. Classic components are not compatible. If you need a new resource, an administrator can create a workspace-based component and share its connection string.

Source text

SKILL.md · MIT
---
name: setup-app-insights
description: Configure optional customer-owned Application Insights telemetry for a Power Apps mobile app — enable it against an existing Azure resource, change the resource, or disable it. Standalone, and invoked by /edit-app.
user-invocable: true
allowed-tools: Read, Write, Edit, Glob, Grep, Bash, AskUserQuestion, Skill
model: opus
---

> **Plugin check**: Run `node "${PLUGIN_ROOT}/scripts/check-version.js"` - if it outputs a message, show it to the user before proceeding.

**Shared instructions: [shared-instructions.md](../../shared/shared-instructions.md)** — read first.

# Set up Application Insights

Configures the generated app's optional, customer-owned Application Insights telemetry through `app.json` → `expo.extra.appInsightsConfig`. This is host/runtime configuration, not a connector or plan section — it never touches the data model, native-capability matrix, connector list, or screens.

Application Insights is **off by default**. Invoking this skill (or approving its mutation) is the explicit opt-in; consent is never inferred from an app description.

## When to use

- `/setup-app-insights` — enable, change, or disable Application Insights on an existing app.
- Invoked by `/edit-app` when the request is only an Application Insights change (its Step 0.5 fast path delegates here).
- Examples: "Enable Application Insights for this app", "Change the Application Insights resource this app uses", "Disable Application Insights for this app".

## When NOT to use

- Adding or changing custom events in app screens → configure Application Insights here first, then continue through `/edit-app` for those source changes.
- Data model / connector / native / design / screen changes → the respective `/add-*`, `/setup-*`, `/edit-app`, or `/design-system` skills.
- Provisioning a new Azure Application Insights resource → out of scope; this skill discovers or accepts an **existing** resource.

## Inputs

- `working_dir` — absolute path to the project root (auto-detected from cwd, or passed by an orchestrator).
- `--action <enable|change-resource|disable>` — optional; when omitted, inferred from current state and one question.

## Step 1 — Detect invocation mode

**Telemetry checkpoint: `resolve_app_insights_mode`**

```
1. Check MOBILE_APP_ORCHESTRATING=1 AND explicit edit-app caller context
   → Mode A (invoked by /edit-app). Use the passed --working-dir. Return a status block.

2. Else resolve working_dir from cwd (must contain app.json with an expo object)
   → Mode B (standalone). Return a human summary.
```

Use the invocation-scoped context from
[app-edit-routing.md](../../shared/references/app-edit-routing.md), not a stale
shell value. Configuration approval remains owned by Step 3 in either mode.

## Step 2 — Inspect and determine the action

**Telemetry checkpoint: `determine_app_insights_action`**

Read, when present:

- `<working_dir>/app.json`
- `<working_dir>/app/_layout.tsx`
- `<working_dir>/package.json`
- `<working_dir>/memory-bank.md`

If `app.json` is missing, malformed, or has no `expo` object, STOP without mutation (`BLOCKED` in Mode A). If uncommitted work overlaps `app.json` or `app/_layout.tsx`, follow the changed-file overlap approval rule in `shared-instructions.md`.

Determine the action:

- `enable` — `appInsightsConfig.enabled` is absent or `false` and the user wants it on.
- `change-resource` — already `enabled: true` and the user wants a different destination.
- `disable` — the user wants Application Insights turned off.
- If intent is ambiguous, ask one `AskUserQuestion` with those three choices, seeded by the current `enabled` state.

## Step 3 — Mutation preview + approval

**Telemetry checkpoint: `review_app_insights_change`**

Show one focused preview and continue only after approval:

```text
─── Application Insights ────────────────────────────
Action        <enable | change resource | disable>
Current       enabled: <true|false>
Configuration app.json → expo.extra.appInsightsConfig
Provider      app/_layout.tsx → PowerAppsProvider appConfig
Sensitive     connection string is never printed or stored in memory-bank.md
```

Ask: `Apply this Application Insights change?`

## Step 4 — Emit the selection telemetry

After the action is confirmed, record the choice through Mobile Apps usage telemetry (`enabled` for enable/change-resource, `disabled` for disable):

```bash
node "${PLUGIN_ROOT}/hooks/run-telemetry.js" \
  app-insights-selection \
  "<enabled-or-disabled>" \
  "<prompt-or-pretool>" \
  '<working_dir>'
```

Pass the invocation source so the event's `invocationSource` matches how the skill was reached: `pretool` in Mode A (delegated from another skill such as `/edit-app` via the Skill tool) and `prompt` in Mode B (the user ran `/setup-app-insights` directly).

This event follows the existing Mobile Apps telemetry controls and contains no Application Insights resource details or connection string. It fails open and never blocks the skill.

## Step 5a — enable / change-resource

**Telemetry checkpoint: `configure_app_insights_resource`**

Discover Application Insights resources visible to the current Azure CLI identity:

```bash
az resource list \
  --resource-type Microsoft.Insights/components \
  --query "[].{name:name,id:id,resourceGroup:resourceGroup,location:location}" \
  -o json
```

Branch on the result:

- **One or more resources returned:** use `AskUserQuestion` to let the user select one. Before configuring it, confirm the selected component is **workspace-based** — `az resource list` returns every `Microsoft.Insights/components`, including classic components, which are not compliant with this skill's contract. Read `properties.WorkspaceResourceId` from the selected resource:

  ```bash
  WORKSPACE_RESOURCE_ID=$(
    az resource show \
      --ids "<selected-resource-id>" \
      --api-version 2020-02-02 \
      --query properties.WorkspaceResourceId \
      -o tsv
  )
  ```

  If `WORKSPACE_RESOURCE_ID` is empty, the resource is a classic (non-workspace-based) component: do **not** configure it. Explain that only a workspace-based Application Insights resource is supported, and let the user select a different resource or use the admin handoff below. Otherwise retrieve its connection string without printing it:

  ```bash
  APP_INSIGHTS_CONNECTION_STRING=$(
    az resource show \
      --ids "<selected-resource-id>" \
      --api-version 2020-02-02 \
      --query properties.ConnectionString \
      -o tsv
  )
  ```

- **Not logged in:** tell the user to run `az login`, then retry discovery once.
- **No subscription/resource access or authorization failure:** explain that Application Insights Azure RBAC is separate from Power Platform and Entra app-registration permissions. Offer an admin handoff: an administrator can create/select one workspace-based Application Insights resource and give the user its connection string.
- **No resources returned:** ask whether the user wants to paste an administrator-provided connection string or leave telemetry disabled. Do not require the user to create Azure resources.

When accepting a pasted connection string, use `AskUserQuestion` freeform and never repeat the answer in chat or command output. Validate only that it contains `InstrumentationKey=` and either an `IngestionEndpoint=` or that the standard public-cloud default can be used. Do not store the connection string in `memory-bank.md`.

Update `<working_dir>/app.json` so `expo.extra.appInsightsConfig` contains:

```json
{
  "expo": {
    "extra": {
      "appInsightsConfig": {
        "enabled": true,
        "connectionString": "<selected-or-pasted-connection-string>",
        "appId": "<appId>",
        "environment": "development",
        "includeUserId": false
      }
    }
  }
}
```

Field rules:

- `appId` — preserve the existing non-empty value; otherwise use `expo.slug`, then `package.json` `name`.
- `environment` / `includeUserId` — preserve existing values; default to `"development"` and `false`. Never turn on user identity collection implicitly.
- Set `enabled: true` and replace only the connection string. Create the `appInsightsConfig` object when missing, and preserve every other `app.json` field.

Never print the connection string, pass it to another agent, write it to `native-app-plan.md` or `memory-bank.md`, or include it in a summary.

### Runtime notes (for screen work that follows)

The app uses `@microsoft/applicationinsights-web` with the React Native manual-device plugin. The first runtime event is `PowerAppsNative.ApplicationStarted`, a deterministic ingestion check after loading the app in Dev Player. The runtime exposes two intentionally different loggers:

```ts
import {
  getAppLogger,
  getCustomEventsLogger,
} from '@microsoft/power-apps-native-host';
```

- `getAppLogger()` is the host/runtime logger; its events continue to Microsoft OneDS and also fan out to the configured Application Insights resource.
- `getCustomEventsLogger()` is for the app's custom events; it goes only to the configured Application Insights resource and is a no-op when custom events are disabled.
- Generate custom event calls only when the user explicitly requested those events or an approved screen spec has a `Custom events` entry. Never use `getAppLogger()` for custom events.
- Telemetry properties must be approved scalar values (result codes, durations, counts, screen identifiers, operation names). Never include form values, free text, record titles, names, emails, phone numbers, tokens, precise coordinates, nested objects, or complete URLs.

Persist in `memory-bank.md` (never the connection string):

```markdown
- Custom events: enabled
- Custom events app ID: <appId>
- Custom events resource ID: <selected-resource-id or admin-provided>
- Custom events destination: one customer-owned workspace-based Application Insights resource
```

## Step 5b — disable

**Telemetry checkpoint: `disable_app_insights`**

Set `enabled: false`, clear `connectionString`, and preserve `appId` and `environment` when present. Keep `includeUserId: false` unless an existing explicitly approved value must be preserved. Do not require Azure sign-in or resource discovery.

```json
{
  "expo": {
    "extra": {
      "appInsightsConfig": {
        "enabled": false,
        "connectionString": "",
        "appId": "<appId>",
        "environment": "development",
        "includeUserId": false
      }
    }
  }
}
```

Persist `Custom events: disabled` and the app ID in `memory-bank.md`; remove stale resource ID / destination lines.

## Step 6 — Verify the provider wiring

**Telemetry checkpoint: `verify_app_insights_provider`**

Confirm `app/_layout.tsx` imports the root `app.json` and passes the complete object to `PowerAppsProvider`:

```tsx
import appConfig from '../app.json';

<PowerAppsProvider appConfig={appConfig}>
```

If either part is missing, patch only the import and the `appConfig` prop; preserve all other provider props and layout behavior. Run `npx --no-install tsc --noEmit` only when `app/_layout.tsx` changed.

Parse `app.json` with Node after the mutation and assert:

- `enable` / `change-resource`: `enabled === true` and `connectionString` is non-empty.
- `disable`: `enabled === false` and `connectionString === ""`.

## Step 6.5 — Offer operation instrumentation (enable / change-resource only)

**Telemetry checkpoint: `offer_operation_instrumentation`**

This skill only wires the telemetry pipeline; it never edits screens or generated services. Enabling Application Insights emits host-level signals (app load, unhandled errors, navigation) automatically, but **domain events like `todo_created` or `order_deleted` are custom events and require source changes**. Those changes belong to `/edit-app` → screen-planner → screen-builder, which emit named events through `getCustomEventsLogger` under the existing scalar-only, no-PII allowlist. Offer that follow-up here; never instrument operations from this skill.

Run this step only after a successful `enable` or `change-resource`. Skip it entirely for `disable`.

- **Mode B (standalone):** ask one `AskUserQuestion`, defaulting to **No** (instrumentation is opt-in, mirroring Application Insights being off by default):

  > Application Insights is on. Want me to add custom events for your app's major operations (create / update / delete)?

  - **Yes** → invoke `/edit-app` with a scoped instrumentation brief and let its normal edit flow discover the entities, screens, and operation boundaries (this skill does not read the data model or screens):

    ```
    Invoke skill: /edit-app

    Arguments:
      Add custom events at each successful create, update, and
      delete boundary for the app's main entities. Emit named events through
      getCustomEventsLogger with approved scalar properties only — no
      operation results, response payloads, form values, free text, record
      titles, personal identifiers, tokens, precise coordinates, nested
      objects, or complete URLs. Use trackScenario() for any duration.
    ```

  - **No** → finish with the normal Mode B summary.

- **Mode A (invoked by `/edit-app`):** do **not** ask the user or re-invoke `/edit-app` from here — that would loop back into the orchestrator. Instead signal the available follow-up in the return block (`instrumentation_offer: available`) so `/edit-app` surfaces the offer after the fast path completes.

## Support boundary

This skill discovers or accepts an **existing** Application Insights resource; it does not provision Azure resources. If the user lacks Azure access and has no administrator-provided connection string, leave telemetry disabled without blocking — the app runs fine with custom events off.

## Return

**Mode A (invoked by `/edit-app`) — status block, first line is the status code:**

```
DONE
action: <enable|change-resource|disable>
enabled: <true|false>
app_id: <appId>
layout_patched: <yes|no>
instrumentation_offer: <available|none>
```

`instrumentation_offer` is `available` only after a successful `enable`/`change-resource` (see Step 6.5); use `none` for `disable` or when telemetry was not turned on. Use `DONE_WITH_CONCERNS: <list>` when applied with caveats (e.g. an admin-provided string that could not be verified), `NEEDS_CONTEXT: <missing>` when a required input is unavailable, and `BLOCKED: <reason>` when `app.json` is unusable.

**Mode B (standalone) — human summary:**

> Application Insights <enabled|updated|disabled> for this app.
> Configuration: `app.json` → `expo.extra.appInsightsConfig`
> To change the resource or turn it off later, run `/setup-app-insights` again.

After an `enable`/`change-resource`, if the user accepted the Step 6.5 offer, note that operation instrumentation was handed to `/edit-app`; if they declined, mention they can run `/edit-app` later to add custom operation events.

© Microsoft · MIT · microsoft/power-platform-skills

Similar skills

All skills for Mobile →
azure-monitor-opentelemetry-exporter-py Microsoft azure-monitor-opentelemetry-exporter-py — a skill for low-level OpenTelemetry export of traces, metrics and logs to Application Insights from Python. Useful when you run a custom telemetry pipeline. CX Codex +1 1installs azure-monitor-opentelemetry-exporter-java Microsoft azure-monitor-opentelemetry-exporter-java is a Claude Code skill sending Java traces, metrics, and logs to Azure Monitor and Application Insights; autoconfigure replaces the deprecated exporter. CX Codex +1 ★ 3,232repo stars python-azure-iot-edge-modules official github python-azure-iot-edge-modules is a GitHub Copilot skill for designing and validating Python modules for Azure IoT Edge. It covers telemetry processing, deployment planning, and network failure handling. CX Codex +1 47installs appinsights-instrumentation davila7 appinsights-instrumentation is a Claude Code command that connects a web app to Azure App Insights telemetry. It runs when asked to add telemetry to an application. CX Codex +1 91installs setting-up-cloudwatch-observability aws setting-up-cloudwatch-observability is a Claude Code skill for initial CloudWatch Omni or Application Signals setup. It routes setup requests to guidance for the relevant product and task. CX Codex +1 2,100installs dt-setup-android Dynatrace dt-setup-android instruments an Android app with the Dynatrace Mobile Agent for initial telemetry. Configures Gradle files, agent credentials, and user privacy opt-in. CX Codex +1 1,200installs

From the same set157

The whole set →
add-seo add-seo adds robots.txt, sitemap.xml, meta tags, and Open Graph config to Power Pages SPA sites. Useful when preparing an existing portal for search engines. CX Codex +1 ★ 1,167repo stars setup setup is a Claude Code skill that prepares Power Automate CLI prerequisites when setup is new or something fails. It checks the required tools and Azure sign-in. CX Codex +1 ★ 1,167repo stars pcf pcf is a skill that builds, tests, upgrades and deploys PCF code components for model-driven apps and Power Pages, including field, dataset and React controls. CX Codex +1 ★ 1,167repo stars create-webroles create-webroles sets up web roles for Power Pages sites directly in metadata files. It handles permission flags for anonymous and authenticated visitors without manual UUID editing. CX Codex +1 ★ 1,167repo stars build-ios-binary build-ios-binary compiles a PAM control's iOS Obj-C or Swift module into a flat device-slice .framework for a .ppmplugin bundle. Mac with Xcode only. CX Codex +1 ★ 1,167repo stars add-connector add-connector adds Power Platform connectors to Expo and React Native Power Apps mobile projects when no dedicated connector skill exists. CX Codex +1 ★ 1,167repo stars force-link-environment force-link-environment is a Claude Code skill that moves a Power Platform Pipelines environment to another host. It runs when the current host association blocks setup or a host change is requested. CX Codex +1 ★ 1,167repo stars create-code-app create-code-app — a Microsoft skill that turns Claude Code into a Power Apps code app builder. Describe what you need and it scaffolds a React and Vite project, then deploys it to Power Platform. CX Codex +1 ★ 1,167repo stars

Project sponsors

Companies that keep this analytics open