Observability

from bb_ai_sdk.observability import init, get_tracer_provider
from bb_ai_sdk.ai_gateway import AIGateway
from openinference.instrumentation.openai import OpenAIInstrumentor

# Step 1: initialize observability
init(agent_name="my-agent")

# Step 2: instrument OpenAI library
# Openaiinstrumentor monkey-patches the OpenAI library to capture all LLM calls
provider = get_tracer_provider()
OpenAIInstrumentor().instrument(tracer_provider=provider)

# Step 3: create AI gateway - all calls are now traced
gateway = AIGateway.create(
    model_id="gpt-4o",
    agent_id="550e8400-e29b-41d4-a716-446655440000"
)

# Step 4: make LLM calls - automatically traced!
response = gateway.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}]
)

from bb_ai_sdk.observability import init, get_tracer_provider
from openinference.instrumentation.agno import AgnoInstrumentor

# Step 1: initialize observability
init(agent_name="my-agent")

# Step 2: instrument Agno framework
# Agnoinstrumentor monkey-patches the Agno framework to capture all LLM calls
provider = get_tracer_provider()
AgnoInstrumentor().instrument(tracer_provider=provider)

# Your Agno agent code here - all calls are automatically traced

from bb_ai_sdk.observability import init, trace

init(agent_name="my-agent")

@trace()
def process_user_request(user_input: str) -> str:
    """This function is automatically traced."""
    # Your logic here
    return "processed result"

@trace(name="custom-span-name")
def validate_input(data: dict) -> bool:
    """Trace with a custom name for clarity."""
    return True

@trace(attributes={
    "prompt.version": "v1.2.3",
    "prompt.name": "customer-support-prompt",
    "user.id": "user-123",
    "session.id": "session-456",
    "experiment.variant": "A"
})
def run_experiment():
    """Traces include all custom attributes for analysis."""
    pass

from bb_ai_sdk.observability import init, trace_context

init(agent_name="my-agent")

def complex_operation():
    with trace_context("multi-step-operation") as span:
        # Add events during execution
        span.add_event("Step 1: Validating input")
        validate_input()
        
        span.add_event("Step 2: Processing data")
        result = process_data()
        
        # Add attributes dynamically
        span.set_attribute("result.count", len(result))
        span.add_event("Step 3: Complete")
        
        return result

init(
    agent_name="my-agent",
    otlp_batch_size=512,        # Max spans per batch (default: 512)
    otlp_batch_timeout=5.0,     # Max wait time in seconds (default: 5.0)
    otlp_max_queue_size=10000   # Max buffered spans (default: 10000)
)

init(
    agent_name="my-agent",
    resource_attributes={
        "service.version": "1.2.3",
        "deployment.region": "us-east-1",
        "deployment.cluster": "prod-cluster-1",
        "custom.tenant.id": "tenant-123"
    }
)

# App.py - at the top
from bb_ai_sdk.observability import init
init(agent_name="my-agent")

# Then import and use other modules

# ✅ good: use optional parameters for better organization
init(
    agent_name="customer-support-agent",
    environment="production",              # Filter traces by environment
    organization_id="org-123",            # Enable multi-tenant cost attribution
    organization_name="Acme Corp",        # Human-readable for dashboards
    resource_attributes={
        "service.version": "1.2.3",       # Track deployments
        "deployment.region": "us-east-1", # Filter by region
        "team": "platform-team"           # Group by team
    }
)

# ❌ bad: minimal configuration limits filtering options
init(agent_name="my-agent")  # Can't filter by environment or organization

# ✅ good: descriptive names
@trace(name="validate-user-input")
@trace(name="fetch-customer-data")

# ❌ bad: generic names
@trace(name="process")
@trace(name="step1")

@trace(attributes={
    "customer.tier": "premium",
    "request.type": "balance-inquiry",
    "channel": "mobile-app"
})

# ✅ good: use environment
init(agent_name="my-agent", backend="langfuse")

# ❌ bad: hardcode credentials
init(agent_name="my-agent", langfuse_public_key="pk-xxx")

import logging
import sys
import http.client

# Enable HTTP connection debugging
http.client.HTTPConnection.debuglevel = 1

# Configure detailed logging
logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s [%(levelname)s] %(name)s - %(message)s",
    handlers=[logging.StreamHandler(sys.stdout)],
)

# Enable opentelemetry component logging
logging.getLogger("opentelemetry").setLevel(logging.DEBUG)
logging.getLogger("opentelemetry.sdk").setLevel(logging.DEBUG)
logging.getLogger("opentelemetry.exporter").setLevel(logging.DEBUG)

# Now initialize observability
from bb_ai_sdk.observability import init
init(agent_name="my-agent")

from bb_ai_sdk.observability import get_current_trace_id

trace_id = get_current_trace_id()
if trace_id:
    logger.info(f"Processing request", extra={"trace_id": trace_id})

from bb_ai_sdk.observability import get_current_span

span = get_current_span()
if span:
    span.set_attribute("user.action", "clicked_button")
    span.add_event("User interaction recorded")

from bb_ai_sdk.observability import get_tracer_provider

provider = get_tracer_provider()

# Use with instrumentors
from openinference.instrumentation.openai import OpenAIInstrumentor
OpenAIInstrumentor().instrument(tracer_provider=provider)

@trace(attributes={
    "api_key": "sk-secret-key-123",  # Automatically redacted to "[REDACTED]"
    "user.name": "John"              # Not redacted, safe to log
})
def my_function():
    pass