Self-hosted service
odigos-io/odigos avatar
odigos-io/odigos

Odigos ships one Dockerfile for every service and computes its own image tag from whichever tool is installed

Distributed tracing without code changes. 🚀 Instantly monitor any application using OpenTelemetry and eBPF

3,672 stars256 forksGoApache-2.0

At a glance

What is it?
Odigos is a Go implementation of distributed tracing that instruments Java, Python, .NET, Node.js and Go processes through eBPF and emits OpenTelemetry, with no application code changes. The install is one command; the build system around it is where the interesting decisions sit.
Who is it for?
Odigos fits a platform team that wants traces from an application it cannot rebuild, and the honest reason is Go: the page says compiled languages have historically been hard to instrument without touching code, and eBPF is the mechanism that changes that. It does not fit a team that wants to know which backend it is committing to, because the page routes the destination list to an anchor it does not define.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 11 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 4, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • odigos-io/odigos3,672 ★ · -3
Star history
Repository2026-09-242026-11-04
odigos-io/odigos3.7k3.7k

-3 Stars in the last 41 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The image tag is whichever of three tools happens to be installed on the machine

The Makefile does not take a version as an argument. It derives one:

code
TAG ?= $(shell odigos version --cluster 2>/dev/null || odigos version --cli 2>/dev/null || helm search repo odigos 2>/dev/null | awk '$$1 == "odigos/odigos" {print $$3}')

Three fallbacks in order: the version of Odigos running in the cluster, then the version of the local CLI, then a chart version scraped out of a helm repo search and filtered to the odigos/odigos chart with awk. Every failure is silenced with 2>/dev/null.

So the tag is a property of the machine doing the build. A workstation with the CLI installed produces one value, a CI runner with only helm configured produces another, and a bare container with neither produces an empty TAG that is not checked by anything in the file. Two builds of the same commit can therefore carry different image tags, and nothing in the repository records which rule produced a published tag.

The default image namespace is docker.io/keyval, not the project's own name

Three registry variables sit at the top of the Makefile and none of them defaults to a path under the project's name:

code
OSS_ORG ?= docker.io/keyval
ENTERPRISE_ORG ?= registry.odigos.io
CENTRAL_BACKEND_URL ?=

An open source build with no overrides pushes to docker.io/keyval. A build with STAGING_ORG=true switches to us-central1-docker.pkg.dev/odigos-cloud/staging-components, a hosted package registry. The enterprise variable is never selected by default, but its presence, plus the empty CENTRAL_BACKEND_URL and the comment about local deploy resolving the registry through a script, tells you the build is parameterised for more than one distribution channel.

The lint configuration is version-pinned as well: GOLANGCI_LINT_VERSION defaults to v2.10.1. The module list is discovered by searching for every go.mod outside vendor and filtering out anything under a directory called licenses, which is how the licence bundle generated during a RHEL build stays out of the module loop.

One Dockerfile builds every service from a single argument, and lint only runs inside a module

The Dockerfile is parameterised by SERVICE_NAME and is used to build each service in turn. It starts from a pinned builder image, golang:1.26.6, and copies the go.mod and go.sum of eleven local modules before any source, so dependency downloads are cached before the tree is copied in. It then runs go mod download and go mod verify from the service module, copies the full sources, and builds:

code
CGO_ENABLED=0 GOARCH=$TARGETARCH go build -ldflags="${LD_FLAGS}" -a -o /workspace/build/$SERVICE_NAME cmd/main.go

Three build arguments decide the shape: TARGETARCH for the architecture, LD_FLAGS for the version stamped into the binary, and RHEL, which switches on a make licenses step and selects a second stage based on registry.access.redhat.com/ubi9. The Makefile adds the matching image suffix, -rhel-certified, in that case.

One line in the Makefile needs the directory you are standing in. The lint command is golangci-lint run with -c ../.golangci.yml, a path that only resolves from inside a module directory, which is why it is built as a variable to be expanded by the per-module loop rather than run from the root.

The link to the supported destinations points at an anchor no heading defines

The section about keeping existing tools says the project supports all the popular managed and open-source destinations, that it produces data in the OpenTelemetry format, and that it can be used with any observability tool supporting OTLP. Then it says: for a complete list of supported destinations, see here, linking to #supported-destinations.

There is no heading by that name in the page. The sections are What is Odigos, Why choose Odigos, Key Features, Language Agnostic Auto-instrumentation, Keep your existing observability tools, Collectors Management, Installation, Contributing, Thanks to our Contributors and License. The anchor resolves to nothing.

What the page does offer is a link to a backends overview on the documentation site, so the list exists, just not where the page says it does. For a tool whose selling point is that it is vendor agnostic, that is the one piece of evidence a reader would want on the page itself, and a reader who clicks the link gets a dead anchor instead.

Collector scaling is the one subsystem with a web interface

Automatic scaling is listed as a feature and then given its own section: Odigos scales OpenTelemetry collectors based on the volume of observability data, and collectors are managed and configured through a web UI. That is the only management interface the page describes, and it belongs to the collector tier rather than to the instrumentation.

The reason the page gives for its performance claim is architectural rather than numerical. Separating data recording from processing is listed as the second reason to choose the project, so the recording agent and the processing pipeline are separate processes and the hot path stays small. No latency figure, no throughput number and no memory measurement appears anywhere to support it.

The repository layout follows that split. autoscaler/ holds the scaling logic, collector/ the collector side, odiglet/ the in-node agent, operator/ the Kubernetes operator, and instrumentor/ with instrumentation/ and instrumentationrules/ the eBPF instrumentation itself. procdiscovery/ and deviceplugin/ handle process discovery and GPU access on the node.

Go is the reason eBPF is in the design, and the page says so

The language section is the clearest argument the project makes. It supports Java, Python, .NET, Node.js and Go, and it states that compiled languages like Go have historically been difficult to instrument without code changes, and that eBPF is what solves that. The description at the top of the repository makes the same pairing: distributed tracing without code changes, using OpenTelemetry and eBPF.

That framing also explains the shape of the tree. There is a dedicated agent, an instrumentation package, an instrumentation rules package and a Kubernetes device plugin, which is what a runtime-level hook needs and what a library-based instrumenter would not. The opampserver/ directory points the other way, at remote configuration of the agent rather than local instrumentation.

The four reasons the page gives for choosing the project are simplicity, performance, community and expertise, with expertise attributed to the maintainers being multiple maintainers of OpenTelemetry. The community reason is a GitHub star count and a contributor base, which is a popularity argument rather than a technical one, and it is the only claim on the page with no mechanism attached.

A stable release and two pre-releases landed within three hours of each other

Three releases share one date, 2026-10-04. v1.39.0-pre1 is stamped 09:36, v1.38.0-rc3 is stamped 09:54, and v1.38.0 is stamped 12:36. So the pre-release of the next version was published eighteen minutes before the third candidate of the current one, and the stable release came three hours after the first.

Read as a list ordered by version, that ordering looks wrong. Read by timestamp it is a plausible sequence, and it tells you the release pipeline publishes candidates as they are built rather than gating them.

The last push to main is dated 2026-10-03, the day before all three releases, so the tagged code was already on the branch. Two root documents are about that process: VERSIONING.md and MIGRATION.md, alongside DEVELOPMENT.md, SECURITY.md, CODE_OF_CONDUCT.md and CONTRIBUTING.md. The page itself contains no upgrade note, so what a version bump requires is in those files rather than here.

The root carries an AGENTS.md, a licence step and a directory for tracing itself

The repository root mixes build files, governance files and engineering notes in one place. .golangci.yml and .goreleaser.yaml sit next to AGENTS.md, DEVELOPMENT.md, MIGRATION.md, VERSIONING.md, SECURITY.md and CODE_OF_CONDUCT.md, with cli.mk and crc.mk as two included makefiles alongside the main Makefile. A .devcontainer/ and a .vscode/ directory are there for editors.

Two entries are worth a second look. AGENTS.md is an instructions file for coding agents, committed where a contributor would expect a contributor guide instead. And own-observability/ is a directory for observing the project with itself, which is the sort of thing that either becomes documentation or becomes dead weight, and nothing on the page says which.

Everything else in the root tree is a Go module or a deployment artefact: api/, autoscaler/, collector/, common/, config/, destinations/, distros/, docs/, frontend/, helm/, instrumentation/, instrumentor/, k8sutils/, opampserver/, operator/, profiles/, recommendations/, scheduler/, scripts/, status/, tests/ and tests-infrastructure/. Two service trees, actions/ and hooks/, and the device plugin, sit alongside them.

Editorial conclusion

Odigos fits a platform team that wants traces from an application it cannot rebuild, and the honest reason is Go: the page says compiled languages have historically been hard to instrument without touching code, and eBPF is the mechanism that changes that. It does not fit a team that wants to know which backend it is committing to, because the page routes the destination list to an anchor it does not define. Check three things before you install. Which collector destination you point OTLP at, since the list is on the documentation site rather than the page. Whether your nodes can run eBPF, which the page does not tie to a kernel version. And, if you build the images yourself, that the default registry namespace in the Makefile is docker.io/keyval rather than the project's own name.

Frequently asked questions

How do I install Odigos?

Download the CLI and run `odigos install`. The page states that installing takes less than five minutes and requires no code changes, and it links an installation page and a quickstart guide on its documentation site for anything beyond that single command.

Which languages can Odigos instrument without code changes?

Java, Python, .NET, Node.js and Go. The page says compiled languages such as Go were historically difficult to instrument without code changes, and that eBPF is the mechanism that closes that gap.

Does Odigos commit you to one observability vendor?

It emits traces in the OpenTelemetry format and works with any destination that accepts OTLP. The page claims support for all popular managed and open-source destinations and links a backends overview, while its own link for the complete list points at an anchor no heading on the page defines.

What does Odigos need from a Kubernetes cluster or a virtual machine?

The page states support for Kubernetes environments and virtual machines, automatic scaling of OpenTelemetry collectors by data volume, and collector configuration through a web UI. It gives no minimum Kubernetes version and no kernel version for the eBPF instrumentation.

Which licence is Odigos released under?

Apache 2.0, with the LICENSE file at the repository root. The Makefile also carries an enterprise registry variable and an empty central backend URL variable for builds that are not the open source default, whose image namespace is docker.io/keyval.

Official sources

  1. License: Apache-2.0
  2. odigos-io/odigos on GitHub
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/odigos-io-odigos.svg)](https://hysenlabs.com/projects/odigos-io-odigos)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/odigos-io-odigos.svg)](https://hysenlabs.com/projects/odigos-io-odigos)

Was this useful?