npm install @arizeai/openinference-instrumentation-openai @opentelemetry/api @opentelemetry/instrumentation @opentelemetry/resources @opentelemetry/sdk-trace-base @opentelemetry/sdk-trace-node @opentelemetry/exporter-trace-otlp-grpc @grpc/grpc-js

import { registerInstrumentations } from "@opentelemetry/instrumentation";
import { OpenAIInstrumentation } from "@arizeai/openinference-instrumentation-openai";
import { ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
import { NodeTracerProvider, BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { OTLPTraceExporter as GrpcOTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
import { Metadata } from "@grpc/grpc-js";

const metadata = new Metadata();
metadata.set("arize-space-id", "your-space-id");
metadata.set("arize-api-key", "your-api-key");

const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    "model_id": "your-project-name",
    "model_version": "v1",
  }),
  spanProcessors: [
    new BatchSpanProcessor(new ConsoleSpanExporter()),
    new BatchSpanProcessor(
      new GrpcOTLPTraceExporter({
        url: "https://otlp.arize.com/v1",
        metadata,
      })
    ),
  ],
});

registerInstrumentations({
  instrumentations: [new OpenAIInstrumentation({})],
});

provider.register();

go get github.com/Arize-ai/arize-otel-go

import (
    "context"
    "log"
    "time"

    arizeotel "github.com/Arize-ai/arize-otel-go"
    "go.opentelemetry.io/otel/attribute"
)

func main() {
    ctx := context.Background()

    tp, err := arizeotel.Register(ctx, arizeotel.Options{
        ProjectName: "your-project-name",
        // Endpoint: arizeotel.EndpointArizeEurope, // for EU spaces
        // SimpleProcessor: true,                   // tests / short CLIs
        ExtraResourceAttributes: []attribute.KeyValue{
            attribute.String("deployment.environment", "prod"),
            attribute.String("model.version", "v1"),
        },
    })
    if err != nil {
        log.Printf("register tracer: %v", err)
        return
    }
    defer func() {
        shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()
        _ = tp.Shutdown(shutdownCtx)
    }()
}

import (
    "context"
    "os"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

ctx := context.Background()

arizeExporter, _ := otlptracehttp.New(ctx,
    otlptracehttp.WithEndpoint("otlp.arize.com"),
    otlptracehttp.WithHeaders(map[string]string{
        "space_id": os.Getenv("ARIZE_SPACE_ID"),
        "api_key":  os.Getenv("ARIZE_API_KEY"),
    }),
)
consoleExporter, _ := stdouttrace.New(stdouttrace.WithPrettyPrint())

// openinference.project.name is required so the collector can route spans to the right project.
res, _ := resource.New(ctx, resource.WithAttributes(
    attribute.String("openinference.project.name", "your-project-name"),
    attribute.String("model.version", "v1"),
))

tp := sdktrace.NewTracerProvider(
    sdktrace.WithBatcher(arizeExporter),    // production export to Arize
    sdktrace.WithBatcher(consoleExporter),  // local debugging — drop in production
    sdktrace.WithResource(res),
)
otel.SetTracerProvider(tp)
defer tp.Shutdown(ctx) // flushes batched spans before exit

import { trace } from "@opentelemetry/api";

const activeSpan = trace.getActiveSpan();
// enrich activeSpan with attributes, events, etc.

import "go.opentelemetry.io/otel/trace"

currentSpan := trace.SpanFromContext(ctx)
// enrich currentSpan with attributes, events, etc.