import spendtrace
spendtrace.auto_instrument()   # patches boto3, openai, anthropic SDKs

from spendtrace import cost_track

@cost_track(feature="ai_recommendations")
def recommend(user_id: str):
    items = dynamo.get_item(...)          # captured automatically
    response = bedrock.invoke_model(...)  # captured automatically
    return response

from spendtrace import SQLiteStorage

storage = SQLiteStorage("cost_data.db")
for row in storage.aggregate_by_feature():
    svc = row["service_costs"]
    print(
        f"{row['feature']:<25}"
        f"  dynamodb=${svc.get('dynamodb', 0):.4f}"
        f"  bedrock=${svc.get('bedrock', 0):.4f}"
        f"  total=${row['total_cost']:.4f}"
        f"  ({row['transaction_count']} calls)"
    )

from spendtrace import reconcile

report = reconcile(
    db_path="cost_data.db",
    start="2026-02-01",
    end="2026-03-01",
)
print(report.summary())

storage.restate_historical_costs(
    factor=report.global_calibration_factor,
    start_date="2026-02-01",
    end_date="2026-03-01",
)

from spendtrace import track_request

@track_request(endpoint="/api/search", user_id=current_tenant_id)
def handle_request(query):
    return search_products(query)   # all nested costs attributed to this tenant

for row in storage.aggregate_by_user():
    print(f"{row['user_id']:<20}  ${row['total_cost']:.4f}/month  ({row['transaction_count']} requests)")

from spendtrace import get_feature_cost_breakdown

for row in get_feature_cost_breakdown(db_path="cost_data.db"):
    print(
        f"{row['feature']:<25}"
        f"  direct=${row['direct_cost']:.6f}"
        f"  fully_loaded=${row['fully_loaded_cost']:.6f}"
    )

from spendtrace import get_request_cost

for req in get_request_cost(db_path="cost_data.db", limit=20):
    print(f"{req['endpoint']:<30}  ${req['total_cost']:.6f}/call  ({req['tx_count']} spans)")

from spendtrace import get_request_subtree

tree = get_request_subtree("req-abc-123", db_path="cost_data.db")
for node in tree:
    indent = "  " * node["depth"]
    print(f"{indent}{node['feature']:<20}  subtree=${node['subtree_cost']:.6f}")

from spendtrace import set_alert

set_alert(
    feature="ai_recommendations",
    threshold=10.00,          # USD
    window_hours=24,
    webhook="https://hooks.slack.com/services/...",   # Slack, PagerDuty, or any HTTP POST
)

from spendtrace import get_cost_trend

for day in get_cost_trend(feature="ai_recommendations", days=30):
    print(day["date"], f"${day['total_cost']:.4f}")

from spendtrace import cost_track, add_api_call

@cost_track(feature="search")
def search_products(query):
    add_api_call("dynamodb_read", count=3)
    add_api_call("bedrock_claude_3_haiku", input_tokens=512, output_tokens=128)

from spendtrace import track

async def process():
    async with track(feature="embeddings", operation="batch"):
        await embed_documents(...)

from spendtrace import create_task_with_context

task = create_task_with_context(child_coroutine())

from spendtrace import set_global_sample_rate, set_circuit_breaker, CircuitBreaker

# Sample 10% of calls in high-traffic paths
set_global_sample_rate(0.10)

# Per-decorator override
@cost_track(feature="search", sample_rate=0.05)
def search(): ...

# Protect your app if the storage layer struggles
set_circuit_breaker(CircuitBreaker(error_threshold=10, recovery_timeout_sec=300))

from spendtrace import SQLiteStorage

storage = SQLiteStorage("cost_data.db")
storage.set_retention(raw_data_days=30, hourly_rollups_days=365, daily_rollups_days=1825)

from spendtrace import AWSCostModel, get_tracker

model = AWSCostModel()
model.api_costs["dynamodb_read"] = 0.000000275   # your negotiated rate
get_tracker().cost_model = model