OpenTelemetry Ingestion

Vortik fully supports the industry-standard OpenTelemetry protocol for ingesting data. This gives you complete visibility into your AI workloads, beyond just the requests passing through the Gateway.

Why use OpenTelemetry?

OpenTelemetry is the leading open-source observability framework. By ingesting your telemetry data into Vortik, you can:

• Unified Monitoring: View traces, logs, and metrics from your AI services alongside your app's existing telemetry.
• Rich Traces: Track entire AI operations-from preprocessing to multi-step LLM chains-in a single, unified view.
• Provider Agnostic: Keep your code clean by using official OpenTelemetry SDKs, avoiding vendor lock-in.

Sending Data to Vortik

Just point your OpenTelemetry SDK or collector to the Vortik endpoint using your API key.

Configuring your SDK

Use the following parameters:

• Endpoint: https://eu.otel.vortik.ai/v1/traces
• Headers: x-api-key: YOUR_VORTIK_API_KEY
• Protocol: otlp/http (preferred) or otlp/grpc

Example Configuration

Node.js

import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { Resource } from '@opentelemetry/resources';
import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';

const sdk = new NodeSDK({
  resource: new Resource({
    [SemanticResourceAttributes.SERVICE_NAME]: 'my-ai-app',
  }),
  traceExporter: new OTLPTraceExporter({
    url: 'https://eu.otel.vortik.ai/v1/traces',
    headers: {
      'x-api-key': 'YOUR_VORTIK_API_KEY',
    },
  }),
});

sdk.start();

Python

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.resources import SERVICE_NAME, Resource

resource = Resource(attributes={
    SERVICE_NAME: "my-ai-app"
})

provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(OTLPSpanExporter(
    endpoint="https://eu.otel.vortik.ai/v1/traces",
    headers={"x-api-key": "YOUR_VORTIK_API_KEY"}
))
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

.NET

using OpenTelemetry;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddSource("my-ai-app")
    .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("my-ai-app"))
    .AddOtlpExporter(opt => {
        opt.Endpoint = new Uri("https://eu.otel.vortik.ai/v1/traces");
        opt.Protocol = OtlpExportProtocol.HttpProtobuf;
        opt.Headers = "x-api-key=YOUR_VORTIK_API_KEY";
    })
    .Build();

Go

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/sdk/resource"
    "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
)

exporter, _ := otlptracehttp.New(context.Background(),
    otlptracehttp.WithEndpoint("eu.otel.vortik.ai"),
    otlptracehttp.WithURLPath("/v1/traces"),
    otlptracehttp.WithHeaders(map[string]string{
        "x-api-key": "YOUR_VORTIK_API_KEY",
    }),
)

tp := trace.NewTracerProvider(
    trace.WithBatcher(exporter),
    trace.WithResource(resource.NewWithAttributes(
        semconv.SchemaURL,
        semconv.ServiceNameKey.String("my-ai-app"),
    )),
)
otel.SetTracerProvider(tp)

PHP

<?php
use OpenTelemetry\SDK\Trace\TracerProvider;
use OpenTelemetry\SDK\Trace\SpanProcessor\BatchSpanProcessor;
use OpenTelemetry\Exporter\OTLP\Http\Exporter;

$exporter = new Exporter([
    'url' => 'https://eu.otel.vortik.ai/v1/traces',
    'headers' => ['x-api-key' => 'YOUR_VORTIK_API_KEY']
]);

$processor = new BatchSpanProcessor($exporter);
$provider = new TracerProvider($processor);

AI Instrumentation

Vortik is built to recognize AI-specific attributes in your OpenTelemetry spans automatically. Include these attributes, and we'll categorize the data to provide advanced dashboard insights.

Recognized AI Attributes

Vortik relies on the OpenTelemetry semantic conventions for AI. Useful attributes include:

• gen_ai.request.model: The LLM model requested.
• gen_ai.response.model: The actual model that provided the response.
• gen_ai.usage.prompt_tokens: Token count of the prompt.
• gen_ai.usage.completion_tokens: Token count of the generation.
• gen_ai.system: The AI provider (e.g., openai, anthropic).

Exploring Data

Once your OpenTelemetry data is flowing, you can dive into it in the Observability tab of the Vortik Dashboard. You get:

• Traces: Full waterfall views of every AI request lifecycle.
• Logs: Relevant logs correlated perfectly to every trace.
• Performance metrics: Real-time charts of latency, throughput, and error rates.
• Cost analysis: Aggregated cost information based on your usage and provider pricing.

---

Continue to Monitoring & Costs to see how Vortik helps you stay on budget.