Arize Skills plugin

---
name: arize-instrumentation
description: Adds Arize AX tracing to an LLM application for the first time. Detects the stack, routes to the single matching integration doc, wires auto-instrumentation after user confirmation, and verifies traces land. 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.
metadata:
  author: arize
  version: "2.0"
---

# Arize Instrumentation Skill

Add **Arize AX tracing** to an app for the first time: **detect the stack → fetch the one matching integration doc → wire auto-instrumentation → verify a trace lands.**

**Route locally.** Map the detected stack to a single doc page via [references/integration-routing.md](references/integration-routing.md) and fetch **only that page**. When the app uses an agent framework, route on the **framework**, not the provider SDK it wraps — a bare `openai`/`anthropic` import inside a framework app is not the integration target; route to a provider page only when the app calls the provider SDK directly with no framework in play. When the stack isn't listed there, search [llms.txt](https://arize.com/docs/llms.txt) for its integration page per the router; with no match, use [manual instrumentation](https://arize.com/docs/ax/instrument/manual-instrumentation). Never bulk-read the [PROMPT.md](https://arize.com/docs/PROMPT.md) aggregate.

**Rules:** inspect before mutating; tracing is additive, never change business logic; follow existing style; no secrets in code and **never ask the user to paste secrets (API keys, tokens) into the chat** -- reference `ARIZE_API_KEY`/`ARIZE_SPACE_ID` env vars only, set by the user in their own `.env`/shell; preserve or ask for the app's Arize region/export endpoint instead of assuming US -- see [references/regions-and-endpoints.md](references/regions-and-endpoints.md); ask before persistent local state (`ax` profiles, `.zshrc`, env vars) -- see [references/ax-profiles.md](references/ax-profiles.md).

## Phase 1: Analysis (read-only — no code/files)

Detect from manifests + imports: language, package manager, LLM providers, frameworks, existing tracing (`TracerProvider`, `register()`, `ARIZE_*`/`OTEL_*`, Datadog/Honeycomb), existing Arize endpoint/region config (`ARIZE_COLLECTOR_ENDPOINT`, an in-code Arize endpoint option, or an `OTEL_EXPORTER_OTLP_ENDPOINT` confirmed to target Arize), and whether the app runs tools / an agent loop (manual CHAIN/TOOL spans only if the matched framework instrumentor doesn't already cover them — decided in Phase 2). **Confirm scope first** — a monorepo, multiple services, or multiple frameworks needs a "which one?" question before touching anything; don't pick for the user.

Output a short summary (stack, proposed integration, existing tracing, scope). If the target is clear and the user asked to instrument now, continue; if ambiguous or analysis-only was requested, stop and confirm.

## Phase 2: Implementation (after the target is confirmed)

1. **Fetch the matched integration doc** and follow its install + wiring verbatim.
2. **Install** with the detected package manager, before writing code — exact packages come from the matched doc. Python base: `arize-otel` (current PyPI release) + `openinference-instrumentation-{name}` (package hyphens, import underscores). TS/JS: `@opentelemetry/sdk-trace-node` + the matched `@arizeai/openinference-*` (or a first-party exporter, e.g. Mastra's `@mastra/arize`). Go has **no integration doc** — see [references/go.md](references/go.md) for install, wiring, flush, and manual spans.
3. **Credentials and region** — app needs an API key + Space + exporter endpoint/region. Inspect only the target app's own config; never scan sibling repos/shell files, surface secrets, or accept a pasted key. See [references/credentials-and-config.md](references/credentials-and-config.md), [references/regions-and-endpoints.md](references/regions-and-endpoints.md), and [references/ax-profiles.md](references/ax-profiles.md).
4. **Centralize** init in one module, **before** any LLM client is created. Existing OTel → add Arize as an *additional* exporter; don't replace it.

5. **Filter non-GenAI spans when the selected TypeScript integration supports a filter.** Make this the default for the Arize exporter so generic HTTP/fetch, framework, and infrastructure spans do not flood the project. For Vercel AI SDK v7 with `@arizeai/openinference-vercel`, set `spanFilter: isOpenInferenceSpan` and `reparentOrphanedSpans: true` on `OpenInferenceSimpleSpanProcessor`; otherwise AI spans can retain references to filtered-out HTTP parents. For Mastra with `@mastra/observability`, configure `spanFilter: span => span.type !== SpanType.GENERIC` on the Arize observability config, after checking that the app does not rely on GENERIC spans as its only user-facing boundary. Do not assume a universal OpenTelemetry option: inspect the matched integration's current API. If it has no filter, avoid enabling unrelated HTTP/auto-instrumentations for the Arize pipeline, or use a supported processor/collector filter that retains the intended GenAI spans. Keep useful semantic request boundaries; filtering policy should not silently discard the app's only user input/final answer span.