Phoenix Tracing

From the author

OpenInference semantic conventions and instrumentation for Phoenix AI observability. Use when implementing LLM tracing, creating custom spans, or deploying to production.

— the description by jimbobbennett

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Phoenix Tracing provides a structured framework for implementing observability in LLM-based applications. It covers the full lifecycle of trace management, including setup, auto and manual instrumentation, span type definitions, and production deployment. The skill offers specific guidance for both Python and TypeScript environments, enabling developers to capture detailed telemetry for LLM calls, retrieval processes, agent reasoning, and evaluation feedback.

What it does

Provides setup instructions for Python and TypeScript SDKs.
Defines OpenInference semantic conventions for various span types like LLM, retriever, and agent.
Supports both auto-instrumentation and manual custom span creation.
Enables feedback collection through annotations on traces, spans, documents, and sessions.
Offers guidance on production concerns such as batch processing and PII masking.
Facilitates organization of trace data by projects and user sessions.

When to use it

When you need to implement observability for LLM applications.
When you want to track multi-step workflows or agent reasoning processes.
When you need to add custom metadata or feedback annotations to your traces.
When preparing your LLM application for production monitoring.
When you need to ensure your instrumentation follows OpenInference standards.

Advantages

Standardized tracing using OpenInference conventions.
Supports both Python and TypeScript ecosystems.
Granular control over span types and custom attributes.
Built-in support for human, LLM, and code-based feedback annotations.
Comprehensive documentation for both development and production deployment.

Usage examples

“How do I set up Phoenix tracing in my Python project?”: The agent provides the installation steps for the arize-phoenix-otel package and demonstrates how to configure the endpoint to begin capturing traces.
“How can I add a custom span for an LLM call in TypeScript?”: The agent guides you through using the @arizeai/phoenix-otel library to wrap your LLM API calls with the appropriate span attributes.
“How do I add human feedback to a specific span?”: The agent shows the code pattern for using the client.spans.add_span_annotation method, including how to specify the label, score, and explanation.
“What are the best practices for production tracing?”: The agent explains how to implement batch processing and PII masking to ensure efficient and secure trace data collection in a production environment.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/github/phoenix-tracing/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip phoenix-tracing.zip -d .agents/skills

Documentation by jimbobbennett

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.
instrumentation-auto-typescript - Auto-instrument supported frameworks
instrumentation-manual-python - Custom spans with decorators
instrumentation-manual-typescript - Custom spans with wrappers

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

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
references/attributes-*         # Attribute specifications

# 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-otel API reference
Python Client Package - arize-phoenix-client API reference

TypeScript API Documentation:

TypeScript Packages - @arizeai/phoenix-otel, @arizeai/phoenix-client, and other TypeScript packages

Files

ATTRIBUTION.mdAdded by AutoGineer935 B
LICENSEAdded by AutoGineer10.0 KiB
README.md842 B
SKILL.md6.3 KiB
references/annotations-overview.md3.8 KiB
references/annotations-python.md3.1 KiB
references/annotations-typescript.md4.0 KiB
references/fundamentals-flattening.md1.8 KiB
references/fundamentals-overview.md1.8 KiB
references/fundamentals-required-attributes.md2.4 KiB
references/fundamentals-universal-attributes.md2.3 KiB
references/instrumentation-auto-python.md2.2 KiB
references/instrumentation-auto-typescript.md2.2 KiB
references/instrumentation-manual-python.md4.9 KiB
references/instrumentation-manual-typescript.md4.6 KiB
references/metadata-python.md1.8 KiB
references/metadata-typescript.md1.1 KiB
references/production-python.md1.5 KiB
references/production-typescript.md3.5 KiB
references/projects-python.md1.4 KiB
references/projects-typescript.md1.1 KiB
references/sessions-python.md2.3 KiB
references/sessions-typescript.md5.3 KiB
references/setup-python.md3.4 KiB
references/setup-typescript.md3.8 KiB
references/span-agent.md378 B
references/span-chain.md1.3 KiB
references/span-embedding.md2.7 KiB
references/span-evaluator.md1.6 KiB
references/span-guardrail.md1.4 KiB
references/span-llm.md3.0 KiB
references/span-reranker.md3.2 KiB
references/span-retriever.md3.4 KiB
references/span-tool.md2.6 KiB

references/production-python.md

Phoenix Tracing: Production Guide (Python)

CRITICAL: Configure batching, data masking, and span filtering for production deployment.

Metadata

Attribute	Value
Priority	Critical - production readiness
Impact	Security, Performance
Setup Time	5-15 min

Batch Processing

Enable batch processing for production efficiency. Batching reduces network overhead by sending spans in groups rather than individually.

Data Masking (PII Protection)

Environment variables:

export OPENINFERENCE_HIDE_INPUTS=true          # Hide input.value
export OPENINFERENCE_HIDE_OUTPUTS=true         # Hide output.value
export OPENINFERENCE_HIDE_INPUT_MESSAGES=true  # Hide LLM input messages
export OPENINFERENCE_HIDE_OUTPUT_MESSAGES=true # Hide LLM output messages
export OPENINFERENCE_HIDE_INPUT_IMAGES=true    # Hide image content
export OPENINFERENCE_HIDE_INPUT_TEXT=true      # Hide embedding text
export OPENINFERENCE_BASE64_IMAGE_MAX_LENGTH=10000  # Limit image size

Python TraceConfig:

from phoenix.otel import register
from openinference.instrumentation import TraceConfig

config = TraceConfig(
    hide_inputs=True,
    hide_outputs=True,
    hide_input_messages=True
)
register(trace_config=config)

Precedence: Code > Environment variables > Defaults

Span Filtering

Suppress specific code blocks:

from phoenix.otel import suppress_tracing

with suppress_tracing():
    internal_logging()  # No spans generated

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

The author says: Requires Phoenix server. Python skills need arize-phoenix-otel; TypeScript skills need @arizeai/phoenix-otel.

Security

What our scanner noticed· Low risk

Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Claude API
AnthropicOfficial
Comprehensive reference for integrating Anthropic's Claude API, SDKs, and Managed Agents into your applications.
Data and AIClaude CodeClaude appsOpenAI Codex+14 more
Apache-2.0Medium riskHas scriptsGitHub stars of the source repository188.6k
Transformers
K-Dense· Community
Integrate Hugging Face Transformers for model loading, inference, and fine-tuning across NLP, vision, and audio tasks.
Data and AIClaude CodeClaude appsOpenAI Codex+14 more
MITLow riskGitHub stars of the source repository56.4k
Open Notebook
K-Dense· Community
Integrate with the self-hosted Open Notebook platform to automate research ingestion, context-aware chat, and AI-driven analysis.
Data and AIClaude CodeClaude appsOpenAI Codex+14 more
MITLow riskHas scriptsGitHub stars of the source repository56.4k
Vision Sft
Seth Hobson· Community
A structured workflow for supervised fine-tuning of vision-language models, focusing on adapter configuration and silent failure prevention.
Data and AIClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository42.3k
LLM Evaluation
Seth Hobson· Community
A comprehensive framework for evaluating LLM application performance using automated metrics, human feedback, and LLM-as-a-judge techniques.
Data and AIClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository42.3k
Lora Qlora Recipes
Seth Hobson· Community
Provides configuration recipes and best-practice hyperparameters for LoRA and QLoRA supervised fine-tuning.
Data and AIClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository42.3k

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download phoenix-tracing.zip