from netra import Netra
from netra.instrumentation.instruments import InstrumentSet

Netra.init(
    app_name="my-ai-app",
    instruments={InstrumentSet.OPENAI, InstrumentSet.FASTAPI},
)

import { Netra, NetraInstruments } from "netra-sdk";

await Netra.init({
    appName: "my-ai-app",
    headers: `x-api-key=${process.env.NETRA_API_KEY}`,
    instruments: new Set([NetraInstruments.OPENAI, NetraInstruments.EXPRESS]),
});

from netra import Netra
from netra.session_manager import ConversationType


def handle_request(request):
    Netra.set_user_id(request.user_id)
    Netra.set_session_id(request.session_id)
    Netra.set_tenant_id(request.tenant_id)

    Netra.set_custom_attributes("customer_tier", request.customer_tier)
    Netra.set_custom_attributes("region", request.region)

    Netra.add_conversation(
        conversation_type=ConversationType.INPUT,
        role="user",
        content=request.message,
    )

    response = run_agent(request.message)

    Netra.add_conversation(
        conversation_type=ConversationType.OUTPUT,
        role="assistant",
        content=response,
    )

    Netra.set_custom_event(
        event_name="request_completed",
        attributes={"status": "success"},
    )

    return response

from netra import Netra, SpanType, UsageModel, ActionModel
from netra.decorators import workflow, agent, task, span


@workflow(name="order-fulfillment")
def fulfill_order(order: dict):
    return OrderAgent().orchestrate(order)


@agent
class OrderAgent:
    @task(name="validate-order")
    def validate(self, order: dict):
        if not order.get("items"):
            raise ValueError("Order must contain at least one item")

    @span(name="shipping-quote", as_type=SpanType.TOOL)
    def dispatch(self, order: dict):
        with Netra.start_span("persist-order") as custom:
            custom.set_usage([
                UsageModel(
                    model="gpt-4o",
                    usage_type="generation",
                    units_used=1,
                    cost_in_usd=0.01,
                )
            ])
            custom.set_action([
                ActionModel(
                    action="DB",
                    action_type="INSERT",
                    metadata={"table": "orders"},
                    success=True,
                )
            ])
            custom.add_event("order.persisted", {"order_id": order.get("id")})
        return {"status": "queued", "order_id": order.get("id")}

    def orchestrate(self, order: dict):
        self.validate(order)
        return self.dispatch(order)

from netra import Netra

Netra.init(app_name="my-service", enable_metrics=True, metrics_export_interval_ms=30000)
meter = Netra.get_meter("my-service")

requests = meter.create_counter("llm.requests.total", unit="1")
errors = meter.create_counter("llm.errors.total", unit="1")
latency = meter.create_histogram("llm.latency_ms", unit="ms")
active = meter.create_up_down_counter("llm.active_requests", unit="1")

from netra import Netra

Netra.init(app_name="my-app")


def task_fn(input_data):
    # Replace with your app invocation and return output text.
    return my_agent_response(input_data)


dataset = Netra.evaluation.get_dataset(dataset_id="YOUR_DATASET_ID")
result = Netra.evaluation.run_test_suite(
    name="baseline-eval",
    data=dataset,
    task=task_fn,
)

print(result)

import { Netra } from "netra-sdk-js";
import OpenAI from "openai";

const client = new Netra({ apiKey: process.env.NETRA_API_KEY! });
const openai = new OpenAI();

async function taskFn(inputData: any): Promise<string> {
  const response = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        messages: [{ role: "user", content: String(inputData) }],
  });
  return response.choices[0].message.content || "";
}

const dataset = await client.evaluation.getDataset("dataset-123");

if (dataset) {
  const result = await client.evaluation.runTestSuite(
     "baseline-eval",
     dataset,
     taskFn,
     ["correctness", "relevance"],
     10
  );
  console.log(result?.runId);
}

import { Netra } from "netra-sdk-js";
import { BaseTask, TaskResult } from "netra-sdk-js/simulation";

const client = new Netra({ apiKey: process.env.NETRA_API_KEY! });

class MyAgentTask extends BaseTask {
    constructor(private readonly agent: any) {
        super();
    }

    async run(message: string, sessionId?: string | null): Promise<TaskResult> {
        const response = await this.agent.chat(message, { sessionId });
        return {
            message: response.text,
            sessionId: sessionId || "default",
        };
    }
}

const result = await client.simulation.runSimulation({
    name: "Customer Support Simulation",
    datasetId: "dataset-123",
    task: new MyAgentTask(myAgent),
    context: { environment: "staging" },
    maxConcurrency: 5,
});

console.log(result?.completed.length, result?.failed.length);