Docs / Implementation guides BUILD WITH TELEMIO Instrument the stack you actually run. Copy a working starting point, connect securely, and verify telemetry at every layer—from mobile apps to JVM services and AI agents.
IMPLEMENTATION EXPLORER Start with the layer you are instrumenting Choose your application layer first. Compare languages within backend services, without jumping into unrelated workflows. Telemio provides a first-party TypeScript SDK; the Java, Python, and Collector paths use OpenTelemetry.
Backend services Web applications Mobile applications AI agents Infrastructure
Instrument API requests and business operations in trusted services.
Node.js / TypeScript Java / Spring Boot Python / FastAPI
Node.js checkout API Add a business span and completion counter inside a trusted server. Requires a server-side ingest credential.
TypeScript · @telemio/sdk Copy code
import { createTelemio } from "@telemio/sdk";
const telemetry = createTelemio({
apiKey: process.env.TELEMIO_API_KEY,
serviceName: "checkout-api",
environment: "production"
});
await telemetry.tracer.withSpan("checkout.complete", async (span) => {
span.setAttribute("checkout.channel", "web");
await telemetry.metrics.count("checkout.completed", 1);
await telemetry.logger.info("Checkout completed");
});Read the full Node.js / TypeScript guide ↗ Spring Boot service Run the OpenTelemetry Java agent and add a meaningful application span. Uses OTLP rather than a Telemio Java SDK.
Java · OpenTelemetry Copy code
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.context.Scope;
Tracer tracer = GlobalOpenTelemetry.getTracer("orders-api");
Span span = tracer.spanBuilder("checkout.complete").startSpan();
try (Scope scope = span.makeCurrent()) {
span.setAttribute("checkout.channel", "web");
processOrder();
} catch (Exception error) {
span.recordException(error);
throw error;
} finally {
span.end();
}Read the full Java / Spring Boot guide ↗ FastAPI service Create business spans in Python while regular OTel instrumentation handles incoming HTTP requests.
Python · OpenTelemetry Copy code
from fastapi import FastAPI
from opentelemetry import trace
app = FastAPI()
tracer = trace.get_tracer("checkout-api")
@app.post("/checkout")
def checkout():
with tracer.start_as_current_span("checkout.complete") as span:
span.set_attribute("checkout.channel", "web")
return {"status": "completed"}Read the full Python / FastAPI guide ↗ Track safe browser interactions using a client-scoped credential.
React storefront Track a safe browser event with a publishable client-scoped key. Never bundle a server API key.
TypeScript · client-safe Telemio SDK Copy code
import { createTelemio } from "@telemio/sdk";
const telemetry = createTelemio({
clientKey: import.meta.env.VITE_TELEMIO_CLIENT_KEY,
appId: "shop-web",
serviceName: "shop-web",
environment: "production"
});
export async function recordSearch(searchType: string) {
await telemetry.track("catalog.search", {
"search.type": searchType
});
}Read the full React / Browser guide ↗ Send sanitized mobile events through a protected gateway.
Mobile application Send only allowlisted events to your backend gateway. The gateway owns the server ingest credential.
TypeScript · protected gateway Copy code
export async function recordScreen(screenName: string) {
await fetch("https://api.example.com/telemetry/events", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
event: "screen.view",
screen: screenName
})
});
}Read the full React Native guide ↗ Trace runtime sessions and tool executions without collecting sensitive prompts.
AI tool execution Capture tool execution with agent-aware spans, without recording prompts or sensitive tool payloads.
TypeScript · @telemio/sdk Copy code
import { createTelemio } from "@telemio/sdk";
const telemetry = createTelemio({
apiKey: process.env.TELEMIO_API_KEY,
serviceName: "support-agent"
});
const toolSpan = telemetry.agent.startTool("knowledge.lookup");
try {
await lookupKnowledge();
} catch (error) {
toolSpan.recordException(error);
toolSpan.setStatus("error");
throw error;
} finally {
await toolSpan.end();
}Read the full AI agent / TypeScript guide ↗ Monitor individual virtual machines and ephemeral workers, or route signals from many services through a shared Collector.
Linux virtual machine Collect CPU, memory, filesystem and network telemetry from a persistent VM or short-lived worker. Correlate agent spans by host.id.
YAML · hostmetrics receiver Copy code
receivers:
hostmetrics:
collection_interval: 30s
scrapers:
cpu:
metrics:
system.cpu.utilization:
enabled: true
memory:
metrics:
system.memory.utilization:
enabled: true
filesystem:
metrics:
system.filesystem.utilization:
enabled: trueRead the full virtual machine guide ↗ Shared OTLP gateway Batch and export traces from many services through a secured Collector. Set the OTLP endpoint and token from your deployment secrets.
YAML · OpenTelemetry Collector Copy code
receivers:
otlp:
protocols:
http:
endpoint: 0.0.0.0:4318
processors:
batch: {}
exporters:
otlphttp/telemio:
endpoint: ${env:TELEMIO_OTLP_ENDPOINT}
headers:
Authorization: "Bearer ${env:TELEMIO_API_KEY}"
service:
pipelines:
traces:
receivers: [otlp]
processors: [batch]
exporters: [otlphttp/telemio]Read the full Collector / Kubernetes guide ↗ Backend services Instrument business operations and APIs. Pick the language your service runs.
IMPLEMENTATION GUIDE Node.js and TypeScript SDK Add spans, logs, metrics and feature flags to a Node.js checkout service.
Read the guide ↗ IMPLEMENTATION GUIDE Java and Spring Boot Auto-instrument a Java service and add useful business spans.
Read the guide ↗ IMPLEMENTATION GUIDE Python and FastAPI Export request traces and custom spans using OpenTelemetry.
Read the guide ↗ Web applications Track user journeys and browser signals using client-safe credentials.
IMPLEMENTATION GUIDE Browser and React Capture safe browser signals using client-scoped ingestion.
Read the guide ↗ Mobile applications Capture events without embedding server credentials in a shipped app.
IMPLEMENTATION GUIDE React Native and mobile Instrument mobile interactions without shipping server ingest secrets.
Read the guide ↗ AI agents Observe tool calls and agent sessions using runtime instrumentation.
IMPLEMENTATION GUIDE AI agents and runtime sessions Observe agent sessions, tool executions, model usage and context metadata.
Read the guide ↗ Infrastructure Track hosts and agent workers on virtual machines, or collect signals from Kubernetes and multiple services.
IMPLEMENTATION GUIDE Virtual machines and ephemeral hosts Monitor Linux VM CPU, memory, filesystem, and running agents with persistent or short-lived host identity.
Read the guide ↗ IMPLEMENTATION GUIDE OpenTelemetry Collector and Kubernetes Route multi-service OTLP signals through a secure Collector gateway.
Read the guide ↗ Before shipping Use a server-side ingest key in trusted services and Collectors, and a restricted client-safe key or telemetry gateway in distributed apps. Developer Connect credentials for reading workspace data are not OTLP ingest credentials.
Start at the quickstart if you do not have a workspace or ingestion endpoint yet. The SDK API reference and credentials guide explain the available surfaces.