import requests

response = requests.get(
    f"https://app.abv.dev/api/public/sessions/{session_id}",
    headers={"Authorization": f"Bearer {api_key}"}
)

session = response.json()
print(f"Traces: {len(session['traces'])}, Cost: ${session['totalCost']:.2f}")

response = requests.get(
    "https://app.abv.dev/api/public/sessions",
    headers={"Authorization": f"Bearer {api_key}"},
    params={"userId": "user-123", "limit": 50}
)

pip install abvdev

from abvdev import observe, ABV

abv = ABV(api_key="sk-abv-...", host="https://app.abv.dev")

@observe()
def process_request(session_id, user_message):
    # Add session ID to the trace
    abv.update_current_trace(session_id=session_id)

    # Process the message
    response = llm.generate(user_message)
    return response

# Simulate a conversation
session_id = "chat-abc-123"
process_request(session_id, "What is the capital of France?")
process_request(session_id, "What about Germany?")
# Both traces belong to session "chat-abc-123"

import uuid

# Option 1: Random UUID
session_id = str(uuid.uuid4())  # "f47ac10b-58cc-4372-a567-0e02b2c3d479"

# Option 2: User-based session ID
user_id = "user-123"
login_timestamp = "20250115-143000"
session_id = f"{user_id}-{login_timestamp}"  # "user-123-20250115-143000"

# Option 3: Conversation ID from your database
session_id = conversation.id  # "conv-abc-789"

from abvdev import ABV

abv = ABV(api_key="sk-abv-...", host="https://app.abv.dev")

# Multi-step workflow with session ID
session_id = "doc-processing-xyz"

# Step 1: Extract text
with abv.start_as_current_span(name="extract-text") as span:
    span.update_trace(session_id=session_id)
    text = extract_text_from_pdf(document)

# Step 2: Summarize text
with abv.start_as_current_span(name="summarize-text") as span:
    span.update_trace(session_id=session_id)
    summary = llm.summarize(text)

# Step 3: Classify topic
with abv.start_as_current_span(name="classify-topic") as span:
    span.update_trace(session_id=session_id)
    topic = llm.classify(summary)

# All 3 traces belong to session "doc-processing-xyz"

with abv.start_as_current_span(name="another-operation"):
    # Add to the current trace
    abv.update_current_trace(session_id="your-session-id")

npm install @abvdev/tracing @abvdev/otel @opentelemetry/sdk-node dotenv

import dotenv from 'dotenv';
dotenv.config();

import { NodeSDK } from '@opentelemetry/sdk-node';
import { ABVSpanProcessor } from '@abvdev/otel';

const sdk = new NodeSDK({
  spanProcessors: [
    new ABVSpanProcessor({
      apiKey: process.env.ABV_API_KEY,
      baseUrl: process.env.ABV_BASE_URL,
      exportMode: 'immediate',
      flushAt: 1,
      flushInterval: 1
    })
  ]
});

sdk.start();

import './instrumentation';
import { startActiveObservation, updateActiveTrace } from '@abvdev/tracing';

async function processChatMessage(sessionId: string, message: string) {
  await startActiveObservation('process-chat-message', async (span) => {
    // Set session ID on trace
    updateActiveTrace({
      sessionId: sessionId
    });

    // Process message
    const response = await llm.generate(message);
    return response;
  });
}

// Conversation
const sessionId = 'chat-abc-123';
await processChatMessage(sessionId, 'What is the capital of France?');
await processChatMessage(sessionId, 'What about Germany?');

import './instrumentation';
import { observe, updateActiveTrace } from '@abvdev/tracing';

// Original function
async function fetchData(sessionId: string, source: string) {
  // Set session ID
  updateActiveTrace({
    sessionId: sessionId
  });

  // Fetch data
  const response = await fetch(source);
  return await response.json();
}

// Wrap with observe
const tracedFetchData = observe(fetchData, {
  name: 'fetch-data-operation'
});

// Use traced version
async function main() {
  const sessionId = 'workflow-xyz-789';
  const result = await tracedFetchData(sessionId, 'https://api.example.com/data');
}

main();

import './instrumentation';
import { startObservation } from '@abvdev/tracing';

const sessionId = 'chat-abc-123';

const span = startObservation('manual-observation', {
  input: { query: 'What is the capital of France?' }
});

// Set session ID on the trace
span.updateTrace({
  sessionId: sessionId
});

span.update({ output: 'Paris' }).end();