What you can monitor with APM
APM coverage by language and platform with the APM agent, the SDK and eBPF, minimum versions, what is not covered and what to do with legacy systems.
On this page
APM receives OpenTelemetry telemetry. An application can get there in three ways, and this page explains what each one covers, from which version, and what it cannot see.
Method | How it works | When to use it |
|---|---|---|
APM agent | Installed on the server, it sets up the language's automatic instrumentation with one command. See APM agents | Linux or Windows servers with Java, .NET, Node.js or Python. This is the recommended option |
SDK with token | The application sends directly to ARGUNIS with an ingest token. See Instrument a server application | Languages without an agent (PHP, Go, Ruby), containers, clouds and the browser |
eBPF | The APM agent observes the application from the operating system, without touching it. See APM agents, section «Observe an application without instrumenting it» | Linux, for programs that can't be instrumented: binaries without source code, old versions or languages without an agent |
With the APM agent
Automatic instrumentation sees the requests the application receives (server spans), the ones it makes to other services and databases, its errors with the exception details, and its runtime's metrics and logs.
Language | Minimum version | System | Main frameworks and libraries |
|---|---|---|---|
Java (and Kotlin) | Java 8 | Linux (systemd service) and Windows (Windows service) | Spring and Spring Boot, Jakarta EE and Servlet, Tomcat, JBoss/WildFly, WebSphere, JDBC (Oracle, SQL Server, PostgreSQL, DB2…), JMS, Kafka, HTTP clients |
.NET Framework | 4.6.2 | Windows (Windows service and IIS) | ASP.NET on IIS, WCF, outgoing HttpClient and WebRequest, SQL Server |
.NET (Core) | .NET 6; OpenTelemetry officially supports the versions Microsoft maintains (currently .NET 8 and later) | Linux (glibc or musl, x64 or arm64) and Windows (Windows service and IIS) | ASP.NET Core, HttpClient, SQL Server, Entity Framework Core, gRPC |
Node.js | Node.js 18.19 (ESM applications, 20.6) | Linux (systemd service) | http, Express, Fastify, NestJS, pg, mysql, MongoDB, Redis, fetch, gRPC, Kafka |
Python | Python 3.9 | Linux (systemd service) | Django, Flask, FastAPI, Celery, requests, psycopg, SQLAlchemy, Redis |
On Windows the agent instruments .NET and Java. A Node.js or Python application on Windows is instrumented with the SDK and a token. On IIS only .NET sites are instrumented.
With the SDK and a token
Language or platform | Minimum version | What it covers |
|---|---|---|
PHP | PHP 8.0 | Laravel, Symfony, Slim, WordPress, PDO, curl and Guzzle, with the official extension |
Go | The Go versions OpenTelemetry maintains (the latest two) | net/http, gRPC and database/sql; in Go you add a few lines at startup |
Ruby | The one required by the official OpenTelemetry gem | Rails, Sinatra, Sidekiq, ActiveRecord, Net::HTTP, Redis |
Java, .NET, Node.js and Python | The same as in the previous table | Same as with the agent, sending directly to ARGUNIS (useful in containers and cloud services) |
Browser (Angular or any web app) | Current browsers | Page load, fetch and XHR, linked to the back-end trace |
Clouds and containers | — | AWS, Azure, Google Cloud, Railway, Kubernetes and Docker, with the same SDKs. See Instrument in clouds and containers |
With eBPF (Linux)
eBPF sees the traffic going in and out of the application, regardless of the language it is written in.
What | Detail |
|---|---|
Requirements | Linux x64 or arm64 with kernel 5.8 or later (or Red Hat Enterprise Linux 8 and derivatives) that exposes BTF, such as Ubuntu 20.10+, Debian 11+ and RHEL 8.2+; with the APM agent installed |
Requests | HTTP 1.x and 2, and gRPC, received and sent, including those encrypted with the system's TLS libraries |
Databases and queues | MySQL, PostgreSQL, SQL Server, Redis, MongoDB 5.0+, Couchbase, Memcached, Kafka, MQTT, NATS, AMQP 1.0 |
Go | Also at the library level: net/http, gRPC, database/sql, Gin, gorilla/mux, go-redis, kafka-go and sarama (Go 1.17+) |
Service name | The executable's name (or the process's |
What is not covered
.NET Framework with
HttpListener: servers built withHttpListener(for example, a Windows service that handles HTTP on its own) do not generate server spans. ASP.NET on IIS, WCF, outgoing HTTP and SQL are visible (verified in the lab). To measure those requests, instrument the caller or add spans with the SDK.Java on IIS and Node.js or Python on Windows with the agent: not supported; use the SDK with a token.
With eBPF:
It sees requests and their calls, but not what happens inside the code: no functions, no exception details, no application-specific metrics.
eBPF traces are not joined across services (each service appears with its requests and dependencies, without the end-to-end trace).
It does not see HTTPS encrypted by the Java application itself: for Java, use the agent.
It does not exist on Windows or on Linux kernels earlier than 5.8 (except RHEL 8).
Already instrumented applications: eBPF skips them to avoid duplicates.
Languages without auto-instrumentation: C, C++, Rust and similar on Linux, with eBPF or with spans sent manually over OTLP; Delphi, Visual Basic 6 and other Windows languages, with manual spans or by measuring from outside.
Legacy systems
System | Why it has no automatic instrumentation | Alternative |
|---|---|---|
Java 6 and 7 | The official OpenTelemetry agent requires Java 8 or later | On Linux, eBPF (HTTP requests, JDBC to MySQL, PostgreSQL or SQL Server). Otherwise, instrument the caller and measure its web services from Applications |
PHP 5 and 7 | The official extension requires PHP 8.0 or later | On Linux, eBPF on the web server and PHP-FPM (requests and database queries) |
.NET Framework earlier than 4.6.2 | The official instrumentation requires 4.6.2 or later, and eBPF does not exist on Windows | Instrument the caller (another service or a proxy) and measure its web services from Applications; logs, with the Collector |
COBOL, RPG, CL and others | They have no runtime that can be instrumented | Instrument the caller, use eBPF on a bridge Linux host, send spans manually over OTLP/HTTP and logs with the Collector. See Instrument on IBM i and legacy systems |
Closed networks or networks that only speak gRPC | They don't reach the internet or don't use OTLP/HTTP | The OpenTelemetry Collector on the customer's network as a bridge to ARGUNIS |
If in doubt, start with the APM agent for the application's language. If that isn't possible, eBPF on Linux. For whatever is left out, measure from outside: web service monitoring in Applications and logs with the Collector.