OpenTelemetry Integration

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http requests

npm install @opentelemetry/sdk-trace-node @opentelemetry/api

import requests
from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult

HUB_ID  = "f47ac10b-58cc-4372-a567-0e02b2c3d479"
API_KEY = "av_agent_sk_..."
API_BASE = "https://api.agentvault.chat"

class AgentVaultExporter(SpanExporter):
    """Minimal OTLP-compatible exporter that posts spans to AgentVault."""

    def export(self, spans):
        otlp_spans = []
        for span in spans:
            ctx = span.get_span_context()
            otlp_spans.append({
                "traceId":           format(ctx.trace_id, "032x"),
                "spanId":            format(ctx.span_id, "016x"),
                "name":              span.name,
                "kind":              "SPAN_KIND_INTERNAL",
                "startTimeUnixNano": str(span.start_time),
                "endTimeUnixNano":   str(span.end_time),
                "status":            {"code": 2 if span.status.is_ok is False else 0},
                "attributes": [
                    {"key": k, "value": {"stringValue": str(v)}}
                    for k, v in span.attributes.items()
                ] if span.attributes else [],
            })

        resp = requests.post(
            f"{API_BASE}/api/v1/telemetry/ingest",
            json={"hub_id": HUB_ID, "spans": otlp_spans},
            headers={"X-Api-Key": API_KEY},
            timeout=10,
        )
        return SpanExportResult.SUCCESS if resp.ok else SpanExportResult.FAILURE

    def shutdown(self):
        pass

import {
  SimpleSpanProcessor,
  SpanExporter,
  ReadableSpan,
  ExportResult,
  ExportResultCode,
} from "@opentelemetry/sdk-trace-base";
import { SpanStatusCode } from "@opentelemetry/api";

const HUB_ID   = "f47ac10b-58cc-4372-a567-0e02b2c3d479";
const API_KEY  = "av_agent_sk_...";
const API_BASE = "https://api.agentvault.chat";

class AgentVaultExporter implements SpanExporter {
  async export(
    spans: ReadableSpan[],
    resultCallback: (result: ExportResult) => void,
  ) {
    const otlpSpans = spans.map((span) => {
      const ctx = span.spanContext();
      return {
        traceId:           ctx.traceId,
        spanId:            ctx.spanId,
        name:              span.name,
        kind:              "SPAN_KIND_INTERNAL",
        startTimeUnixNano: String(hrTimeToNanos(span.startTime)),
        endTimeUnixNano:   String(hrTimeToNanos(span.endTime)),
        status: {
          code: span.status.code === SpanStatusCode.ERROR ? 2 : 0,
        },
        attributes: Object.entries(span.attributes).map(([key, val]) => ({
          key,
          value:
            typeof val === "number"
              ? Number.isInteger(val)
                ? { intValue: val }
                : { doubleValue: val }
              : typeof val === "boolean"
                ? { boolValue: val }
                : { stringValue: String(val) },
        })),
      };
    });

    try {
      const res = await fetch(`${API_BASE}/api/v1/telemetry/ingest`, {
        method:  "POST",
        headers: {
          "Content-Type": "application/json",
          "X-Api-Key": API_KEY,
        },
        body: JSON.stringify({ hub_id: HUB_ID, spans: otlpSpans }),
      });
      resultCallback({
        code: res.ok
          ? ExportResultCode.SUCCESS
          : ExportResultCode.FAILED,
      });
    } catch {
      resultCallback({ code: ExportResultCode.FAILED });
    }
  }

  async shutdown() {}
}

function hrTimeToNanos([s, ns]: [number, number]): bigint {
  return BigInt(s) * 1_000_000_000n + BigInt(ns);
}

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.resources import Resource
import time

resource = Resource(attributes={"service.name": "my-agent"})
provider = TracerProvider(resource=resource)
provider.add_span_processor(SimpleSpanProcessor(AgentVaultExporter()))
trace.set_tracer_provider(provider)

tracer = trace.get_tracer("my-agent")

# Report an LLM call
with tracer.start_as_current_span("llm.inference") as span:
    span.set_attribute("ai.agent.llm.model",         "gpt-4o")
    span.set_attribute("ai.agent.llm.provider",      "openai")
    span.set_attribute("ai.agent.llm.tokens_input",  512)
    span.set_attribute("ai.agent.llm.tokens_output", 148)
    span.set_attribute("ai.agent.llm.latency_ms",    1200)
    # ... your actual LLM call here ...
    time.sleep(1.2)

# Report a tool call
with tracer.start_as_current_span("tool.execute") as span:
    span.set_attribute("ai.agent.tool.name",       "web_search")
    span.set_attribute("ai.agent.tool.success",    True)
    span.set_attribute("ai.agent.tool.latency_ms", 340)

import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
import { trace, SpanStatusCode } from "@opentelemetry/api";

const provider = new NodeTracerProvider();
provider.addSpanProcessor(
  new SimpleSpanProcessor(new AgentVaultExporter()),
);
provider.register();

const tracer = trace.getTracer("my-agent");

// Report an LLM call
const llmSpan = tracer.startSpan("llm.inference");
llmSpan.setAttribute("ai.agent.llm.model",         "claude-3-5-sonnet");
llmSpan.setAttribute("ai.agent.llm.provider",      "anthropic");
llmSpan.setAttribute("ai.agent.llm.tokens_input",  800);
llmSpan.setAttribute("ai.agent.llm.tokens_output", 220);
llmSpan.setAttribute("ai.agent.llm.latency_ms",    950);
llmSpan.end();

// Report a failed tool call
const toolSpan = tracer.startSpan("tool.execute");
toolSpan.setAttribute("ai.agent.tool.name",       "code_executor");
toolSpan.setAttribute("ai.agent.tool.success",    false);
toolSpan.setAttribute("ai.agent.tool.latency_ms", 5000);
toolSpan.setStatus({
  code: SpanStatusCode.ERROR,
  message: "Execution timed out",
});
toolSpan.setAttribute("ai.agent.error.type",    "TimeoutError");
toolSpan.setAttribute("ai.agent.error.message", "Timed out after 5s");
toolSpan.end();

// Flush before shutdown
await provider.forceFlush();
await provider.shutdown();