Session: "support_conversation_789"
│
├── Trace 1: "greeting" (09:00:00)
│   └── "Hi, I need help with billing"
│   └── "Hello! I'd be happy to help..."
│
├── Trace 2: "billing_inquiry" (09:00:15)
│   └── "Can you show me my invoices?"
│   └── "Here are your recent invoices..."
│
├── Trace 3: "payment_update" (09:01:30)
│   └── "I want to update my payment method"
│   └── "I've updated your payment method..."
│
└── Trace 4: "farewell" (09:02:00)
    └── "Thanks for your help!"
    └── "You're welcome! Is there anything else?"

Session metrics:
├── Total turns: 4
├── Duration: 2 minutes
├── Context quality: Did the AI remember previous context?
├── Resolution: Was the user's issue resolved?
└── Satisfaction: How did the conversation end?

Session: "product_research_journey"
├── Search: "best laptops 2024"
├── Compare: "MacBook vs ThinkPad"
├── Details: "MacBook Pro specifications"
├── Reviews: "MacBook Pro user reviews"
└── Purchase: "Add to cart"

from brokle import Brokle, wrap_openai

client = Brokle(api_key="bk_...")
openai_client = wrap_openai(openai.OpenAI(), brokle=client)

class ChatSession:
    def __init__(self, user_id: str):
        self.session_id = f"chat_{uuid.uuid4()}"
        self.user_id = user_id
        self.messages = []

    def send_message(self, user_message: str) -> str:
        self.messages.append({"role": "user", "content": user_message})

        with client.start_as_current_span(
            name=f"chat_turn_{len(self.messages)}"
        ) as span:
            span.update_trace(
                session_id=self.session_id,
                user_id=self.user_id
            )
            span.set_attribute("turn_number", len(self.messages))

            response = openai_client.chat.completions.create(
                model="gpt-4",
                messages=self.messages
            )

            assistant_message = response.choices[0].message.content
            self.messages.append({"role": "assistant", "content": assistant_message})

            span.update(output=assistant_message)
            return assistant_message

# Usage
session = ChatSession(user_id="user_456")
session.send_message("Hello!")
session.send_message("What's the weather like?")
session.send_message("Thanks, goodbye!")
# All three traces are linked by session_id

class AgentSession:
    def __init__(self, task: str, user_id: str):
        self.session_id = f"agent_{uuid.uuid4()}"
        self.task = task
        self.user_id = user_id
        self.step = 0

    def execute_step(self, action: str):
        self.step += 1

        with client.start_as_current_span(name=f"agent_step_{self.step}") as span:
            span.update_trace(
                session_id=self.session_id,
                user_id=self.user_id
            )
            span.set_attribute("step_number", self.step)
            span.set_attribute("action", action)
            span.set_attribute("task", self.task)

            result = perform_action(action)
            span.update(output=result)
            return result

# Agent executing a multi-step task
agent = AgentSession(task="research_competitors", user_id="user_789")
agent.execute_step("search_market")
agent.execute_step("analyze_results")
agent.execute_step("generate_report")
# All steps linked as one session

# Create a session context
session_context = {
    "session_id": "session_123",
    "user_id": "user_456",
    "channel": "web",
    "intent": "product_inquiry",
    "started_at": datetime.now().isoformat()
}

# Apply to each trace in the session
with client.start_as_current_span(name="interaction") as span:
    span.update_trace(
        session_id=session_context["session_id"],
        user_id=session_context["user_id"]
    )
    span.set_attribute("channel", session_context["channel"])
    span.set_attribute("session_intent", session_context["intent"])

Session: support_conversation_789
├── Duration: 2m 15s
├── Total Traces: 4
├── Total Tokens: 2,847
├── Total Cost: $0.0892
├── Avg Quality: 0.87
│
├── Timeline:
│   ├── 09:00:00 - greeting (245 tokens, $0.01)
│   ├── 09:00:15 - billing_inquiry (892 tokens, $0.03)
│   ├── 09:01:30 - payment_update (1,210 tokens, $0.04)
│   └── 09:02:00 - farewell (500 tokens, $0.01)

By Channel:
├── Web: 3.2 avg turns, 85% resolution
├── Mobile: 4.1 avg turns, 78% resolution
└── API: 2.8 avg turns, 92% resolution

By Customer Tier:
├── Enterprise: 2.5 avg turns, 95% resolution
├── Pro: 3.0 avg turns, 88% resolution
└── Free: 4.5 avg turns, 72% resolution

# Good - consistent format
session_id = f"session_{uuid.uuid4()}"

# Avoid - inconsistent formats
session_id = uuid.uuid4()  # Sometimes UUID
session_id = "abc123"      # Sometimes short string

span.update_trace(
    session_id=session_id,
    user_id=user_id  # Don't forget this
)

def should_start_new_session(last_activity: datetime) -> bool:
    """Start new session if inactive for 30 minutes"""
    return datetime.now() - last_activity > timedelta(minutes=30)

# For specific flows, use descriptive session IDs
session_id = f"checkout_{order_id}"
session_id = f"onboarding_{user_id}"
session_id = f"support_ticket_{ticket_id}"