from brokle import Brokle

client = Brokle(api_key="bk_...")

with client.start_as_current_span(name="process_document") as span:
    # Your code here
    result = analyze_document(document)

    # Update span with output
    span.update(output=result)

client.flush()

import { Brokle } from 'brokle';

const client = new Brokle({ apiKey: 'bk_...' });

const span = client.startSpan({ name: 'process_document' });

try {
  const result = await analyzeDocument(document);
  span.end({ output: result });
} catch (error) {
  span.end({ error: error.message });
  throw error;
}

await client.shutdown();

with client.start_as_current_span(name="transform_data") as span:
    # Set input explicitly
    span.update(input={"raw_data": data, "config": config})

    # Perform operation
    result = transform(data, config)

    # Set output
    span.update(output=result)

const span = client.startSpan({
  name: 'transform_data',
  input: { rawData: data, config }
});

const result = await transform(data, config);

span.end({ output: result });

with client.start_as_current_span(name="process_order") as span:
    # Set individual attributes
    span.set_attribute("order_id", order.id)
    span.set_attribute("customer_tier", customer.tier)
    span.set_attribute("item_count", len(order.items))
    span.set_attribute("total_value", order.total)

    # Or batch set via metadata
    span.update(metadata={
        "payment_method": order.payment_method,
        "shipping_speed": order.shipping_speed,
        "has_discount": order.discount is not None
    })

    result = process_order(order)
    span.update(output=result)

const span = client.startSpan({
  name: 'process_order',
  attributes: {
    orderId: order.id,
    customerTier: customer.tier,
    itemCount: order.items.length,
    totalValue: order.total
  }
});

// Add more attributes later
span.setAttributes({
  paymentMethod: order.paymentMethod,
  shippingSpeed: order.shippingSpeed,
  hasDiscount: order.discount !== null
});

const result = await processOrder(order);
span.end({ output: result });

with client.start_as_current_span(name="checkout_flow") as parent:
    parent.set_attribute("cart_id", cart.id)

    # Child span 1: Validate cart
    with client.start_as_current_span(name="validate_cart") as validate_span:
        validation_result = validate_cart(cart)
        validate_span.update(output=validation_result)

        if not validation_result.valid:
            validate_span.update(error="Cart validation failed")
            return

    # Child span 2: Process payment
    with client.start_as_current_span(name="process_payment") as payment_span:
        payment_span.set_attribute("payment_method", cart.payment_method)
        payment_result = charge_customer(cart.total)
        payment_span.update(output={"transaction_id": payment_result.id})

    # Child span 3: Create order
    with client.start_as_current_span(name="create_order") as order_span:
        order = create_order(cart, payment_result)
        order_span.update(output={"order_id": order.id})

    parent.update(output={"order_id": order.id, "status": "completed"})

const parent = client.startSpan({
  name: 'checkout_flow',
  attributes: { cartId: cart.id }
});

// Child span 1: Validate cart
const validateSpan = client.startSpan({
  name: 'validate_cart',
  parentSpanId: parent.spanId
});
const validationResult = await validateCart(cart);
validateSpan.end({ output: validationResult });

if (!validationResult.valid) {
  parent.end({ error: 'Cart validation failed' });
  return;
}

// Child span 2: Process payment
const paymentSpan = client.startSpan({
  name: 'process_payment',
  parentSpanId: parent.spanId,
  attributes: { paymentMethod: cart.paymentMethod }
});
const paymentResult = await chargeCustomer(cart.total);
paymentSpan.end({ output: { transactionId: paymentResult.id } });

// Child span 3: Create order
const orderSpan = client.startSpan({
  name: 'create_order',
  parentSpanId: parent.spanId
});
const order = await createOrder(cart, paymentResult);
orderSpan.end({ output: { orderId: order.id } });

parent.end({ output: { orderId: order.id, status: 'completed' } });

with client.start_as_current_generation(
    name="summarize_document",
    model="gpt-4",
    input={"text": document_text}
) as gen:
    response = openai.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "Summarize the following document."},
            {"role": "user", "content": document_text}
        ]
    )

    gen.update(
        output=response.choices[0].message.content,
        usage={
            "prompt_tokens": response.usage.prompt_tokens,
            "completion_tokens": response.usage.completion_tokens
        }
    )

const gen = client.startGeneration({
  name: 'summarize_document',
  model: 'gpt-4',
  input: { text: documentText }
});

const response = await openai.chat.completions.create({
  model: 'gpt-4',
  messages: [
    { role: 'system', content: 'Summarize the following document.' },
    { role: 'user', content: documentText }
  ]
});

gen.end({
  output: response.choices[0].message.content,
  usage: {
    promptTokens: response.usage.prompt_tokens,
    completionTokens: response.usage.completion_tokens
  }
});

with client.start_as_current_span(name="api_call") as span:
    try:
        result = external_api.call(params)
        span.update(output=result)
    except TimeoutError as e:
        span.update(
            error=f"Timeout after {timeout}s",
            metadata={"error_type": "timeout", "retryable": True}
        )
        raise
    except AuthenticationError as e:
        span.update(
            error="Authentication failed",
            metadata={"error_type": "auth", "retryable": False}
        )
        raise
    except Exception as e:
        span.update(error=str(e))
        raise

const span = client.startSpan({ name: 'api_call' });

try {
  const result = await externalApi.call(params);
  span.end({ output: result });
} catch (error) {
  if (error instanceof TimeoutError) {
    span.end({
      error: `Timeout after ${timeout}s`,
      attributes: { errorType: 'timeout', retryable: true }
    });
  } else if (error instanceof AuthenticationError) {
    span.end({
      error: 'Authentication failed',
      attributes: { errorType: 'auth', retryable: false }
    });
  } else {
    span.end({ error: error.message });
  }
  throw error;
}