AutoGineer
Generated banner for Phoenix Tracing
Generated logo for Phoenix Tracing

Phoenix Tracing

GitHubOfficialFirst committed by jimbobbennettDistributed by GitHub

  • Skill
  • Tool integration
  • Data and AI
  • Apache-2.0
  • Low risk
Download ZIP

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

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/github/phoenix-tracing/download

  2. 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

Phoenix 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

PriorityCategoryDescriptionPrefix
1SetupInstallation and configurationsetup-*
2InstrumentationAuto and manual tracinginstrumentation-*
3Span Types9 span kinds with attributesspan-*
4OrganizationProjects and sessionsprojects-*, sessions-*
5EnrichmentCustom metadatametadata-*
6ProductionBatch processing, maskingproduction-*
7FeedbackAnnotations and evaluationannotations-*

Quick Reference

1. Setup (START HERE)
2. Instrumentation
3. Span Types (with full attribute schemas)
4. Organization
5. Enrichment
6. Production (CRITICAL)
7. Feedback
Reference Files

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:

  1. Start with setup-{lang} for your language

  2. Choose instrumentation-auto-{lang} OR instrumentation-manual-{lang}

  3. Reference span-{type} files as needed for specific operations

  4. See fundamentals-* files for attribute specifications

References

Phoenix Documentation:

Python API Documentation:

TypeScript API Documentation:

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

Files

references/setup-python.md

Phoenix Tracing: Python Setup

Setup Phoenix tracing in Python with arize-phoenix-otel.

Metadata

AttributeValue
PriorityCritical - required for all tracing
Setup Time<5 min

Quick Start (3 lines)

from phoenix.otel import register
register(project_name="my-app", auto_instrument=True)

Connects to http://localhost:6006, auto-instruments all supported libraries.

Installation

pip install arize-phoenix-otel

Supported: Python 3.10-3.13

Configuration

Environment Variables (Recommended)
export PHOENIX_API_KEY="your-api-key"  # Required for Phoenix Cloud
export PHOENIX_COLLECTOR_ENDPOINT="http://localhost:6006"  # Or Cloud URL
export PHOENIX_PROJECT_NAME="my-app"  # Optional
Python Code
from phoenix.otel import register

tracer_provider = register(
    project_name="my-app",              # Project name
    endpoint="http://localhost:6006",   # Phoenix endpoint
    auto_instrument=True,               # Auto-instrument supported libs
    batch=True,                         # Batch processing (default: True)
)

Parameters:

  • project_name: Project name (overrides PHOENIX_PROJECT_NAME)

  • endpoint: Phoenix URL (overrides PHOENIX_COLLECTOR_ENDPOINT)

  • auto_instrument: Enable auto-instrumentation (default: False)

  • batch: Use BatchSpanProcessor (default: True, production-recommended)

  • protocol: "http/protobuf" (default) or "grpc"

Auto-Instrumentation

Install instrumentors for your frameworks:

pip install openinference-instrumentation-openai      # OpenAI SDK
pip install openinference-instrumentation-langchain   # LangChain
pip install openinference-instrumentation-llama-index # LlamaIndex
# ... install others as needed

Then enable auto-instrumentation:

register(project_name="my-app", auto_instrument=True)

Phoenix discovers and instruments all installed OpenInference packages automatically.

Batch Processing (Production)

Enabled by default. Configure via environment variables:

export OTEL_BSP_SCHEDULE_DELAY=5000           # Batch every 5s
export OTEL_BSP_MAX_QUEUE_SIZE=2048           # Queue 2048 spans
export OTEL_BSP_MAX_EXPORT_BATCH_SIZE=512     # Send 512 spans/batch

Link: https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/

Verification

  1. Open Phoenix UI: http://localhost:6006

  2. Navigate to your project

  3. Run your application

  4. Check for traces (appear within batch delay)

Troubleshooting

No traces:

  • Verify PHOENIX_COLLECTOR_ENDPOINT matches Phoenix server

  • Set PHOENIX_API_KEY for Phoenix Cloud

  • Confirm instrumentors installed

Missing attributes:

  • Check span kind (see rules/ directory)

  • Verify attribute names (see rules/ directory)

Example

from phoenix.otel import register
from openai import OpenAI

# Enable tracing with auto-instrumentation
register(project_name="my-chatbot", auto_instrument=True)

# OpenAI automatically instrumented
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello!"}]
)

API Reference

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.

Attribution and licence

First committed by
GitHub avatar of jimbobbennettjimbobbennett
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · skills/phoenix-tracing · commit 797337f
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (written by AutoGineer)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
jimbobbennett, stbenjam

AutoGineer is not affiliated with or endorsed by jimbobbennett or GitHub.

Download ZIP

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