All major code editors supported

Production-grade OTelinstrumentation, automatically.

Analyzes your codebase and auto-generates production-grade OpenTelemetry
instrumentation without you writing a single line of code.
Works in VS Code, Cursor, Windsurf, and more.Analyzes your codebase and auto-generates OTel instrumentation — without you writing a single line of code.

Install extension
Scroll
PythonDjango · Flask · FastAPI
JavaScriptExpress · Fastify · NestJS
TypeScriptExpress · Fastify · NestJS
RustActix-web · Axum
PythonDjango · Flask · FastAPI
JavaScriptExpress · Fastify · NestJS
TypeScriptExpress · Fastify · NestJS
RustActix-web · Axum
PythonDjango · Flask · FastAPI
JavaScriptExpress · Fastify · NestJS
TypeScriptExpress · Fastify · NestJS
RustActix-web · Axum
The instrumentation problem

Getting OTel right is harder
than it should be.

The spec is complex. The imports are endless. Skip it and prod is a black box. There's a better way.

Doing it manually
app.py~2 days per service
from opentelemetry import trace
from opentelemetry.sdk.trace import ...
# ...47 more imports to figure out

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

def process_payment(data):
  with tracer.start_as_current_span(
    "process_payment") as span:
    span.set_attribute("payment.id", ...)
    # ...134 more functions to go
// Result
→ 2 days of work. ~40% coverage.
→ Wrong conventions.
otex
Command Palette~10 minutes
otex: Full Instrumentation

// AI analyzes codebase + framework...
// Generates contextual spans...

✓ tracing generated — 134 spans

~ logging — coming soon
~ metrics — coming soon

// Files backed up. Diff ready to review.
// Result
→ 134 spans. 100% coverage. ~10 minutes.
→ Correct conventions.
The obvious question

Spec-driven.
Not vibes-driven.

LLMs write spans that compile. otex writes spans that are correct — sourced from the OTel semantic conventions spec, every time.

VS CodeCursorWindsurfVSCodiumOpen VSX
Your code gen tool otex
AI Code Gen
otex
Attribute names
INVENTED

Plausible-sounding but wrong — db.query instead of db.statement. Breaks grouping and alerting in prod.

SPEC-EXACT

Every key from the OTel semantic conventions spec. db.system, http.request.method. Always correct.

Coverage
PROMPT-SCOPED

Only instruments what you described. HTTP calls in utilities, DB queries in helpers — all invisible.

FULL AST

Parses your entire codebase. Finds every HTTP call, DB op, and file I/O across every file and framework boundary.

Consistency
NON-DETERMINISTIC

Run it twice, get different span names and structure. Unpredictable output by design.

DETERMINISTIC

Same codebase, same output every time. Spec-driven means predictable, reviewable, safe to ship.

How it works

Four steps.
Fully instrumented.

From zero coverage to production-grade OTel — without you writing a single line of instrumentation code.

01Analyze
02Plan
03Instrument
04Commit
01Analyze
02Plan
03Instrument
04Commit
01Analyze
Analyze 1Analyze 2Analyze 3Analyze 1Analyze 2Analyze 3
02Plan
Plan 1Plan 2Plan 3Plan 1Plan 2Plan 3
03Instrument
Instrument 1Instrument 2Instrument 1Instrument 2
04Commit
Commit 1Commit 2Commit 1Commit 2
Built for production

Instrumented safely.
You stay in control.

Guardrails, coverage visibility, and spec-correct semantics — built in, not bolted on.

Instrumentation only. Nothing else.
otex operates inside strict guardrails. It adds spans, imports, and OTel setup — and nothing else. Your business logic, error handling, and unrelated files are completely untouched.
Zero scope creep
Run output
$ otex: Instrument
src/routes/users.ts— span added
src/db/queries.ts— span added
src/utils/auth.ts— out of scope
2 files changed · 0 unrelated edits
Continuous coverage monitoring
Always-on visibility into what's instrumented and what isn't. No manual audits — gaps surface automatically as your codebase grows.
Always current
OTel semantics, fully handled
Every attribute name sourced directly from the OTel semantic conventions spec. db.system, http.request.method, rpc.service — correct every time.
Spec-driven
Language support

Works with your stack,
out of the box.

Framework-aware instrumentation for the languages you already use — not generic boilerplate.

Python
Django · Flask · FastAPI
JavaScript
Express · Fastify · NestJS
TypeScript
Express · Fastify · NestJS
Rust
Actix-web · Axum

More languages on the way — Go, Java, Ruby, and others are in progress.

From zero to fully observable

Full observability,
without the toil.

Free extension. Bring your Anthropic API key.
Works with Parseable and any OTLP collector.

Install extension