Phoenix Tracing
FreeInstrument LLM applications for observability with OpenInference.
Free · Opens the source repo
What Phoenix Tracing does
Phoenix Tracing is a comprehensive skill designed to facilitate the instrumentation of large language model (LLM) applications using OpenInference tracing conventions. This skill provides a structured approach to setting up tracing for Phoenix AI, covering both Python and TypeScript implementations. It includes detailed reference files that guide users through the process of installation, configuration, and deployment, ensuring that developers can effectively monitor and analyze their LLM applications.
The skill is organized into several categories that streamline the tracing process. Users can start with the setup guides to install the necessary packages and configure their endpoints. Following this, they can choose between auto-instrumentation or manual instrumentation methods, allowing for flexibility based on the specific needs of their application. The skill also covers various span types, enabling users to create custom spans that capture detailed metrics about their LLM operations, such as API calls, document retrieval, and multi-step workflows.
In addition to setup and instrumentation, Phoenix Tracing emphasizes the importance of production readiness. It provides guidelines for batch processing and PII masking, which are critical for deploying applications in a live environment. Users can also track sessions and group traces by project, enhancing the organization of their observability data. This skill is particularly valuable for developers and data scientists who are looking to implement robust monitoring solutions for their LLM applications, ensuring they can derive actionable insights from their trace data.
When to use it
Use Phoenix Tracing when you need to instrument LLM applications for observability, whether you're setting up for the first time or enhancing existing implementations.
When not to use it
This skill may not be suitable for applications that do not utilize LLMs or for users who are not familiar with OpenInference conventions.
What you can build with it
Setting Up Tracing
Follow the setup-{lang} guide to install and configure Phoenix tracing for your LLM application.
Creating Custom Spans
Use the instrumentation-manual-{lang} guide to define and implement custom spans for your specific use cases.
Deploying to Production
Refer to the production-{lang} documentation to ensure your tracing setup is ready for live deployment, including PII masking.
How to install Phoenix Tracing
View source1. Install with the skills CLI
npx skills add arize-ai/phoenix/phoenix-tracing --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by arize-aiPhoenix Tracing
Comprehensive guide for instrumenting LLM applications with OpenInference tracing in Phoenix. Contains reference files covering setup, instrumentation, span types, and production deployment.
When to Apply
Reference these guidelines when:
- Setting up Phoenix tracing (Python or TypeScript)
- Creating custom spans for LLM operations
- Adding attributes following OpenInference conventions
- Deploying tracing to production
- Querying and analyzing trace data
Reference Categories
| Priority | Category | Description | Prefix |
|---|---|---|---|
| 1 | Setup | Installation and configuration | setup-* |
| 2 | Instrumentation | Auto and manual tracing | instrumentation-* |
| 3 | Span Types | 9 span kinds with attributes | span-* |
| 4 | Organization | Projects and sessions | projects-*, sessions-* |
| 5 | Enrichment | Custom metadata | metadata-* |
| 6 | Production | Batch processing, masking | production-* |
| 7 | Feedback | Annotations and evaluation | annotations-* |
Quick Reference
1. Setup (START HERE)
- setup-python - Install arize-phoenix-otel, configure endpoint
- setup-typescript - Install @arizeai/phoenix-otel, configure endpoint
2. Instrumentation
- instrumentation-auto-python - Auto-instrument OpenAI, LangChain, etc. (also covers OTel GenAI native instrumentation)
- instrumentation-auto-typescript - Auto-instrument supported frameworks
- instrumentation-manual-python - Custom spans with decorators
- instrumentation-manual-typescript - Custom spans with wrappers
- instrumentation-atif-python - Import ATIF agent trajectories (Claude Code, OpenHands, Codex, etc.)
3. Span Types (with full attribute schemas)
- span-llm - LLM API calls (model, tokens, messages, cost)
- span-chain - Multi-step workflows and pipelines
- span-retriever - Document retrieval (documents, scores)
- span-tool - Function/API calls (name, parameters)
- span-agent - Multi-step reasoning agents
- span-embedding - Vector generation
- span-reranker - Document re-ranking
- span-guardrail - Safety checks
- span-evaluator - LLM evaluation
4. Organization
- projects-python / projects-typescript - Group traces by application
- sessions-python / sessions-typescript - Track conversations
5. Enrichment
- metadata-python / metadata-typescript - Custom attributes
6. Production (CRITICAL)
- production-python / production-typescript - Batch processing, PII masking
7. Feedback
- annotations-overview - Feedback concepts
- annotations-python / annotations-typescript - Add feedback to spans
Reference Files
- fundamentals-overview - Traces, spans, attributes basics
- fundamentals-required-attributes - Required fields per span type
- fundamentals-universal-attributes - Common attributes (user.id, session.id)
- fundamentals-flattening - JSON flattening rules
Common Workflows
- Quick Start: setup-{lang} → instrumentation-auto-{lang} → Check Phoenix
- Custom Spans: setup-{lang} → instrumentation-manual-{lang} → span-{type}
- Session Tracking: sessions-{lang} for conversation grouping patterns
- Production: production-{lang} for batching, masking, and deployment
How to Use This Skill
Navigation Patterns:
# By category prefix
references/setup-* # Installation and configuration
references/instrumentation-* # Auto and manual tracing
references/span-* # Span type specifications
references/sessions-* # Session tracking
references/production-* # Production deployment
references/fundamentals-* # Core concepts
# By language
references/*-python.md # Python implementations
references/*-typescript.md # TypeScript implementations
Reading Order:
- Start with setup-{lang} for your language
- Choose instrumentation-auto-{lang} OR instrumentation-manual-{lang}
- Reference span-{type} files as needed for specific operations
- See fundamentals-* files for attribute specifications
References
Phoenix Documentation:
Python API Documentation:
- Python OTEL Package -
arize-phoenix-otelAPI reference - Python Client Package -
arize-phoenix-clientAPI reference
TypeScript API Documentation:
- TypeScript Packages -
@arizeai/phoenix-otel,@arizeai/phoenix-client, and other TypeScript packages
Frequently asked questions about Phoenix Tracing
Similar skills
WinMD API Search
Easily find and explore Windows desktop APIs.
WebMCPify
Transform any web app into an agent-ready platform.
Phoenix Tracing
Instrument LLM applications with OpenInference tracing.
Foundry Hosted Agent CopilotKit
Guidance for developing agentic web apps on Azure.
Power Automate Foundation
Connect AI agents to Power Automate seamlessly.
Power Automate Flow Builder
Efficiently build and deploy Power Automate flows programmatically.