HoneyHive Python SDK
  • Tutorials
    • Getting Started Path
      • 1. Set Up Your First Tracer
        • 1.1. Prerequisites
        • 1.2. Installation
        • 1.3. Step 1: Set Up Environment Variables
        • 1.4. Step 2: Initialize Your First Tracer
        • 1.5. Step 3: Make Your First Traced Call
        • 1.6. Step 4: Verify in HoneyHive Dashboard
        • 1.7. Complete Example
        • 1.8. Running the Example
        • 1.9. Troubleshooting
        • 1.10. Next Steps
      • 2. Add LLM Tracing in 5 Minutes
        • 2.1. Before You Start
        • 2.2. Quick Integration (3 Steps)
        • 2.3. Before & After Examples
        • 2.4. Using Environment Variables (Production)
        • 2.5. What Gets Traced Automatically?
        • 2.6. Alternative: Using @trace Decorator (Non-Instrumentor Pattern)
        • 2.7. Multiple Providers in One Application
        • 2.8. Verifying Traces
        • 2.9. Performance Impact
        • 2.10. Common Patterns
        • 2.11. Troubleshooting
        • 2.12. Next Steps
      • 3. Enable Span Enrichment
        • 3.1. What is Span Enrichment?
        • 3.2. Prerequisites
        • 3.3. Basic Enrichment
        • 3.4. enrich_session() vs enrich_span()
        • 3.5. Enrichment Interfaces
        • 3.6. Enrichment in Functions
        • 3.7. Common Enrichment Patterns
        • 3.8. Enrichment Data Types
        • 3.9. Best Practices
        • 3.10. Viewing Enriched Data
        • 3.11. Complete Example
        • 3.12. Next Steps
      • 4. Configure Multi-Instance Tracers
        • 4.1. Why Multiple Tracers?
        • 4.2. Basic Multi-Instance Setup
        • 4.3. Pattern 1: Environment-Based Routing
        • 4.4. Pattern 2: Feature-Based Routing
        • 4.5. Pattern 3: Dynamic Tracer Selection
        • 4.6. Pattern 4: A/B Testing with Multiple Tracers
        • 4.7. Configuration Management
        • 4.8. Best Practices
        • 4.9. Performance Considerations
        • 4.10. Complete Example Application
        • 4.11. Viewing Traces by Project
        • 4.12. Next Steps
      • 5. Tutorial 5: Run Your First Experiment
        • 5.1. What You’ll Learn
        • 5.2. What You’ll Build
        • 5.3. Prerequisites
        • 5.4. Step 1: Install and Setup
        • 5.5. Step 2: Define Your Function
        • 5.6. Step 3: Create Your Test Dataset
        • 5.7. Step 4: Run Your Experiment
        • 5.8. Step 5: View Results in Dashboard
        • 5.9. Step 6: Add Evaluators for Automated Scoring
        • 5.10. Step 7: Run Experiment with Evaluators
        • 5.11. Step 8: View Metrics in Dashboard
        • 5.12. Step 9: Test an Improvement
        • 5.13. What You’ve Learned
        • 5.14. Next Steps
        • 5.15. Complete Code
      • 6. End-to-End Distributed Tracing
        • 6.1. What You’ll Build
        • 6.2. Prerequisites
        • 6.3. Installation
        • 6.4. Step 1: Set Environment Variables
        • 6.5. Step 2: Create the Agent Server (Remote Service)
        • 6.6. Step 3: Create the Client Application
        • 6.7. Step 4: Run and Test
        • 6.8. Step 5: View in HoneyHive
        • 6.9. What You Learned
        • 6.10. Troubleshooting
        • 6.11. Next Steps
    • Additional Learning
      • Advanced Configuration Guide
        • Overview
        • Prerequisites
        • What You’ll Learn
        • Configuration Patterns
        • Advanced Configuration Patterns
        • Production Configuration Strategies
        • Configuration Best Practices
        • Troubleshooting
        • Next Steps
  • How-to Guides
    • Overview
    • Getting Started
      • Where Should I Initialize the Tracer?
        • Overview
        • Quick Decision Matrix
        • Pattern 1: Local Development / Single Trace
        • Pattern 2: Evaluation / Experiments (evaluate())
        • Pattern 3: Serverless (AWS Lambda / Cloud Functions)
        • Pattern 4: Long-Running Server (FastAPI / Flask / Django)
        • Pattern 5: Testing / Multi-Session Scenarios
        • Common Patterns Summary
        • Best Practices
        • Troubleshooting
        • Next Steps
    • Migration & Compatibility
      • Migration Guide: v0.1.0+ Architecture
        • Overview
        • What’s New in v0.1.0+
        • Migration Strategies
        • Detailed Migration Steps
        • Common Migration Scenarios
        • New Features Available
        • Breaking Changes
        • Troubleshooting
        • Getting Help
        • Migration Checklist
        • Conclusion
      • Backwards Compatibility Guide: Main Branch → Complete Refactor
        • Overview
        • Migration is Safe and Seamless
        • Supported Parameters (All 16 Original)
        • Migration Examples
        • Enhanced Features in Complete-Refactor
        • Environment Variable Support
        • New Methods Available
        • Performance Improvements
        • Validation After Migration
        • Rollback Procedure
        • Common Questions
        • Best Practices for Migration
        • Need Help?
    • LLM Provider Integration
      • Integrate with OpenAI
        • Compatibility
        • Choose Your Instrumentor
        • Comparison: OpenInference vs Traceloop for OpenAI
        • Migration Between Instrumentors
        • See Also
      • Integrate with Anthropic
        • Compatibility
        • Choose Your Instrumentor
        • Comparison: OpenInference vs Traceloop for Anthropic
        • Migration Between Instrumentors
        • See Also
      • Integrate with Google AI
        • Compatibility
        • Choose Your Instrumentor
        • Comparison: OpenInference vs Traceloop for Google AI
        • Migration Between Instrumentors
        • See Also
      • Integrate with Google Agent Development Kit (ADK)
        • Compatibility
        • Choose Your Instrumentor
      • Integrate with AWS Bedrock
        • Compatibility
        • Choose Your Instrumentor
        • Comparison: OpenInference vs Traceloop for AWS Bedrock
        • Migration Between Instrumentors
        • See Also
      • Integrate with Azure OpenAI
        • Compatibility
        • Choose Your Instrumentor
        • Comparison: OpenInference vs Traceloop for Azure OpenAI
        • Migration Between Instrumentors
        • See Also
      • AWS Strands Integration
        • Overview
        • Prerequisites
        • Basic Integration
        • Tool Execution
        • Advanced Features
        • Multi-Agent Workflows
        • Integration with evaluate()
        • Span Enrichment
        • What Gets Traced
        • Troubleshooting
        • Best Practices
        • Next Steps
      • Integrate with Model Context Protocol (MCP)
        • Compatibility
        • Choose Your Instrumentor
        • Comparison: OpenInference vs Traceloop for Model Context Protocol (MCP)
        • Migration Between Instrumentors
        • See Also
      • Multi-Provider Integration
        • Overview
        • Choose Your Instrumentor Strategy
        • Quick Start
        • Multi-Provider Agent Workflow
        • Cost Optimization Strategy
        • A/B Testing Across Providers
        • Environment-Based Provider Selection
        • Error Handling and Fallbacks
        • Monitoring Multi-Provider Performance
        • Best Practices
        • See Also
      • Non-Instrumentor Framework Integration
        • Overview
        • Integration Strategies
        • Configuration
        • Best Practices
        • Common Integration Patterns
        • Troubleshooting
        • Advanced Topics
        • See Also
    • Custom Tracing
      • Build Custom Tracing
        • Span Enrichment Patterns
        • Session Enrichment
        • Custom Span Management
        • Class-Level Decorator Patterns
        • Advanced Tracing Patterns
        • Automatic Tracer Discovery
        • When to Use These Guides
    • Testing Your Application
      • Testing Applications with HoneyHive
        • Testing Philosophy
        • Setup for Testing
        • Unit Testing Traced Functions
        • Integration Testing
        • Evaluation Testing
        • Best Practices
        • Common Testing Patterns
        • Running Tests
        • Next Steps
    • Evaluate LLM Outputs
      • Evaluation & Analysis Guides
        • Overview
    • Deploy to Production
      • Setting up HoneyHive in your Python Package Manager
        • Overview
        • Single Provider Integration
        • Multiple Provider Integration
        • Framework-Specific Integration
        • Optional Dependencies Pattern (Recommended)
        • All Integrations (Kitchen Sink)
        • Tool-Specific Examples
        • Available Optional Dependencies
        • Best Practices
        • Migration from Manual Installation
        • Troubleshooting
        • Next Steps
      • Production Deployment Guide
        • Overview
        • Security Configuration
        • Performance Optimization
        • Error Handling & Reliability
        • Container Deployment
        • Production Checklist
    • Monitor & Export
      • How to Export Traces
        • Overview
        • When to Export Traces
        • Export Methods
        • Export Formats
        • Advanced Export Patterns
        • Export Performance Tips
        • Troubleshooting
        • Next Steps
    • Build Common Patterns
      • LLM Application Patterns
        • Agent Architecture Patterns
        • LLM Workflow Patterns
        • Best Practices for LLM Applications
        • Next Steps
    • Troubleshooting
    • Getting Help
  • API Reference
    • Overview
      • Core Capabilities
      • Main Components
    • Core API
      • Client Classes
        • HoneyHive Client API Reference
        • HoneyHiveTracer API Reference
        • Tracer Architecture Overview
        • Configuration Models API
      • Decorators & Functions
        • Decorators API Reference
      • Configuration
        • Hybrid Configuration Approach
        • Configuration Options Reference
        • Environment Variables Reference
        • Authentication Reference
      • Data Models
        • Event Data Models
        • Span Data Models
        • Evaluation Data Models
      • Experiments Module
        • Experiments Module
        • Core Functions
        • Evaluators
        • Results Retrieval
        • Data Models
        • Utility Functions
      • Evaluation Framework (Deprecated)
        • Evaluation Framework API Reference
        • Deprecation Notice
      • Command Line Interface
        • CLI Reference
        • CLI Commands Reference
        • CLI Options Reference
      • Feature Specifications
        • Tracing Features
        • Evaluation Features
        • LLM Integration Features
        • Performance Features
        • Configuration Features
        • Security Features
      • Package Information
  • Explanation
    • Overview
    • Architecture & Design
      • Architecture Overview
        • System Overview
        • Core Architecture Components
        • Key Design Decisions
        • See Also
      • Bring Your Own Instrumentor (BYOI) Design
        • The Problem: Dependency Hell
        • The BYOI Solution
        • How It Works
        • Benefits of BYOI
        • Supported Instrumentor Providers
        • Implementation Details
        • Migration Examples
        • Best Practices
        • Trade-offs and Limitations
        • Future Evolution
        • Conclusion
        • Troubleshooting BYOI Integration
        • Provider Strategy Intelligence
    • Architecture Diagrams
      • System Overview
      • BYOI Architecture
      • Multi-Instance Architecture
      • Data Flow
      • Deployment Patterns
      • Evaluation Architecture
      • Performance Optimization
      • Security Architecture
      • Integration Patterns
      • See Also
    • Fundamental Concepts
      • Tracing Fundamentals
        • What is Distributed Tracing?
        • Core Tracing Concepts
        • LLM-Specific Tracing Considerations
        • Sampling and Performance
        • Trace Analysis Patterns
        • Integration with Monitoring Systems
        • Best Practices Summary
        • See Also
      • LLM Observability Concepts
        • What is LLM Observability?
        • The Challenge with Traditional Observability
        • Key Concepts in LLM Observability
        • LLM-Specific Challenges
        • Observability Architecture Patterns
        • Best Practices for LLM Observability
        • Integration with Development Workflow
        • Conclusion
      • Experiments Architecture
        • What are Experiments?
        • How Experiments Work
        • Data Flow Through the System
        • Experiments vs Traces
        • Evaluation Lifecycle
        • Backend Aggregation
        • Best Practices
        • Common Patterns
        • See Also
    • Compatibility Matrix
    • Understanding the Ecosystem
    • Common Questions
    • Learning Path
    • Further Reading
  • Changelog
    • Latest Release Notes
      • Current Version Highlights
    • Version Upgrade Guide
    • Contributing to the Changelog
    • Release Process
  • SDK Development
    • Testing
      • Testing Setup and Commands
      • Unit Testing Strategies
        • Quick Start
        • Testing Tracer Initialization
        • Testing Span Operations
        • Testing Decorators
        • Testing Multi-Instance Behavior
        • Testing Error Handling
        • Testing Configuration Loading
        • Testing Session Management
        • Testing Performance Impact
        • Mock Testing Utilities
        • Advanced Unit Testing Patterns
        • Test Fixtures and Utilities
        • Running Unit Tests
        • CLI Testing
        • See Also
      • Integration Testing Strategies
        • Quick Start
        • Testing Component Interactions
        • Testing Multi-Instance Patterns
        • Testing LLM Provider Integration
        • Testing Real API Integration
        • Testing Environment Integration
        • Testing Error Scenarios Integration
        • Testing Configuration Integration
        • Testing Performance Integration
        • Running Integration Tests
        • Best Practices
        • See Also
      • Integration Testing Strategy for HoneyHive SDK
        • Overview
        • The ProxyTracerProvider Bug: Lessons Learned
        • Testing Strategy Updates
        • Test Categories and When to Use
        • Test Execution Strategy
        • Preventing Future Bugs
        • Monitoring and Metrics
        • Tools and Infrastructure
        • Conclusion
      • AWS Lambda Testing Guide
        • Quick Start
        • Why Lambda Testing Matters
        • Lambda Testing Infrastructure
        • Local Lambda Testing
        • Performance Testing & Benchmarking
        • CI/CD Integration Testing
        • Production Lambda Testing
        • Lambda Optimization Best Practices
        • Troubleshooting Lambda Issues
        • Lambda Testing Commands
        • Advanced Lambda Testing Scenarios
        • See Also
      • Performance Testing & Benchmarking
        • Quick Start
        • Performance Testing Framework
        • Memory Performance Testing
        • Async Performance Testing
        • Load Testing
        • Lambda Performance Testing
        • Performance Testing Commands
        • Performance Benchmarking
        • Performance Monitoring Integration
        • See Also
      • Mocking Strategies & Test Doubles
        • Quick Start
        • Mock Tracer Creation
        • Patching Strategies
        • Fixture-Based Mocking
        • Mocking External Dependencies
        • Mocking Async Operations
        • Advanced Mocking Patterns
        • Mock Validation Utilities
        • Best Practices for Mocking
        • See Also
      • GitHub Actions CI/CD Testing
        • Our GitHub Actions Workflows
        • Tox Full Suite Workflow
        • Real API Integration Testing
        • AWS Lambda Testing Workflow
        • Documentation Workflows
        • Release Candidate Workflow
        • Internal Development Best Practices
        • Environment Variables in CI
        • Troubleshooting CI Failures
        • Workflow Monitoring and Debugging
        • See Also
      • Troubleshooting Test Issues
        • Quick Diagnostics
        • Common Test Failures
        • Environment Issues
        • Debugging Test Data and Fixtures
        • Async Test Debugging
        • Test Debugging Tools
        • CLI Validation in Tests
        • See Also
      • Workflow Path Detection Optimization
        • Overview
        • Problem Statement
        • Solution Implementation
        • Workflow Trigger Logic
        • Benefits
        • Testing the Detection Logic
        • Maintenance Notes
        • Future Enhancements
        • Related Documentation
    • Release Process
      • Release Process and PyPI Publishing
        • Release Workflow Architecture
        • Version Management
        • Release Procedure
        • PyPI Publishing Workflow Details
        • Integration with CI/CD Pipeline
        • Troubleshooting Release Issues
        • Emergency Manual Release
        • Release Monitoring
        • Version History and Changelog
        • Best Practices
        • See Also
    • AI-Assisted Development Infrastructure
      • Agent OS MCP/RAG Server
        • Overview
        • What is Agent OS?
        • Our Evolution: From Builder Methods to MCP/RAG
        • Architecture
        • Getting Started
        • Using the MCP Tools
        • Development
        • Observability (Dogfooding HoneyHive)
        • Troubleshooting
        • See Also
    • Post-Mortems & Lessons Learned
      • Post-Mortem: ProxyTracerProvider Bug (2025-09-05)
        • Executive Summary
        • Timeline
        • Root Cause Analysis
        • Impact Assessment
        • What Went Wrong
        • What Went Right
        • Lessons Learned
        • Action Items
        • Prevention Measures
        • Conclusion
    • Getting Help
    • Contributing Guidelines
HoneyHive Python SDK
  • Search

© Copyright 2024, HoneyHive AI.

Built with Sphinx using a theme provided by Read the Docs.