loongsuite-go is an Apache-2.0 licensed compile-time instrumentation agent that adds OpenTelemetry tracing and metrics to Go applications without requiring any source-code changes, and it is built for Go teams that need observability across services they would rather not modify by hand.

What it is

Loongsuite Go Agent ships as a command-line tool named otel, maintained in the alibaba/loongsuite-go repository, with documentation hosted at https://alibaba.github.io/loongsuite-go/. Instrumentation happens at compile time rather than at runtime: prefixing an ordinary build command with otel produces a binary that is already wired for OpenTelemetry. The tool pins OpenTelemetry v1.45.0 and injects those OpenTelemetry modules into the application it instruments, which is why both the tool and the target application require Go 1.25 or newer — the OTel modules declare go 1.25.0 from v1.42.0 onward. It is catalogued under Infrastructure & Operations / Monitoring & Observability, and its topics are apm, go, instrumentation, metrics, observability, opentelemetry, and tracing.

The concrete problem it solves is hand-written instrumentation in the Go ecosystem. Normally, giving a Go service OpenTelemetry traces and metrics means adding SDK bootstrap code to the application and wiring per-library hooks into every HTTP handler, database client, message consumer, and logger. loongsuite-go replaces that manual, code-level OpenTelemetry instrumentation with a build step: go build becomes otel go build, and the resulting binary emits telemetry without anyone editing the repository.

Key capabilities

• Compile-time auto-instrumentation through the otel prefix, including otel go build, otel go build -o app cmd/app, and otel go build -gcflags="-m" cmd/app, so ordinary build flags pass through unchanged.
• Injection of pinned OpenTelemetry v1.45.0 modules into the instrumented application, covering tracing and metrics.
• A supported-library matrix with explicit minimum and maximum versions per library, including entries for google.golang.org/adk from v0.2.0 and github.com/rabbitmq/amqp091.
• Auto-instrumentation for github.com/uber-go/zap logging, demonstrated in example/log.
• HTTP request and response monitoring through the nethttp example, plus Kafka consumer message monitoring through the kafka-demo example.
• Integration with the Kratos framework, shown in example/kratos-demo.
• Custom code injection, demonstrated in example/sqlinject for SQL injection detection, alongside a benchmark example for overhead measurement.

Who uses it and how

• Go services that must be observed but cannot easily be edited, such as vendored dependencies, generated code, and applications where a rebuild is cheaper than a refactor.
• Teams already standardized on OpenTelemetry that want consistent traces and metrics across services without hand-writing SDK setup in each one.
• HTTP services that need request and response instrumentation on ingress and egress paths, following the nethttp example.
• Kafka consumer pipelines and microservices built on the Kratos framework, both of which have dedicated end-to-end examples in the repository.
• Applications built on google.golang.org/adk, where the tool covers agent-style Go workloads from v0.2.0 onward.

Getting started

Prebuilt binaries are the recommended installation path, with downloads for Linux AMD64, Linux ARM64, MacOS AMD64, MacOS ARM64, and Windows AMD64 as otel-linux-amd64, otel-linux-arm64, otel-darwin-amd64, otel-darwin-arm64, and otel-windows-amd64.exe. Alternatively, a bash installer places otel in /usr/local/bin/otel, and building from source uses make or make install; verify the tool with otel version, then build the project with otel go build.

How it compares

The facts do not list paid products that loongsuite-go replaces. It sits inside the OpenTelemetry ecosystem as an implementation of that standard rather than an alternative to it, pinning OpenTelemetry v1.45.0 and emitting the same traces and metrics any OpenTelemetry backend can consume, while the README separately links a commercial version hosted on Alibaba Cloud ARMS. No other compile-time Go instrumentation tool is named in the registry facts, so it is presented here without a direct peer for comparison.

When to use it — and when not to

Adoption is gated by Go 1.25 or newer for both the tool and every application it instruments, so teams running older toolchains cannot use it at all. Because instrumentation is injected during compilation, a project that builds cleanly with go build may fail under otel go build; the README states that such failures should be filed as bugs, which means build-time coupling is a real operational consideration rather than a theoretical one. Library coverage is bounded by the published minimum and maximum versions, and the project carries 30 open issues, so anyone needing instrumentation for a library absent from that matrix should not expect it to work. The tool has no described server component, but operators still need an OpenTelemetry-compatible destination for the traces and metrics their instrumented binaries emit.

$ sudo curl -fsSL https://cdn.jsdelivr.net/gh/alibaba/loongsuite-go@main/install.sh | sudo bash

$ make         # build only
$ make install # build and install

$ # You may use "otel-linux-amd64" instead of "otel"
$ otel version

$ otel go build
$ otel go build -o app cmd/app
$ otel go build -gcflags="-m" cmd/app