Open-Source Observability · DataDog

orchestrion

Orchestrion is a Datadog-maintained Go tool that automatically instruments Go code at compile time to enable distributed tracing and APM observability. It integrates seamlessly into the Go build process by reading configuration from an `orchestrion.tool.go` file and inserting instrumentation for supported libraries without code changes.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/DataDog/orchestrion

610

GitHub stars

Forks

Primary language

Apache-2.0

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	DataDog/orchestrion
Owner	DataDog
Primary language	Go
License	Apache-2.0 — OSI-approved
Stars	610
Forks	34
Open issues	19
Latest release	v1.11.0 (2026-06-25)
Last updated	2026-07-06
Source	https://github.com/DataDog/orchestrion

What orchestrion is

Orchestrion performs compile-time AST transformation on Go source code to inject tracing instrumentation. It requires Go modules and supports the two latest Go releases; instrumentation is driven by imports in `orchestrion.tool.go` and works with Datadog's dd-trace-go/v2 tracer or other vendor tracers via pluggable integrations.

Quickstart

Get the orchestrion source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/DataDog/orchestrion.git2cd orchestrion3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Automatic APM with Zero Code Changes

Instrument existing Go services for distributed tracing (metrics, spans, traces) without modifying application source code—only add imports to `orchestrion.tool.go` and rebuild.

Datadog-Native Observability Integration

When already using Datadog's observability platform, Orchestrion provides native, compile-time instrumentation of popular Go libraries (HTTP, databases, message queues, caching) with minimal operational overhead.

Multi-Integration Selective Instrumentation

Cherry-pick which library integrations to enable (e.g., only HTTP and PostgreSQL) by importing specific packages in `orchestrion.tool.go`, keeping binary size and overhead minimal.

Implementation considerations

Requires explicit `orchestrion.tool.go` file at project root with imports to enable instrumentation; zero-config default behavior does not exist.
Only supports two latest Go releases officially; validate compatibility with your Go version before adoption.
Instrumentation is inserted at build time; debugging requires `-work` flag to inspect modified source and diagnose issues.
Integration support depends on whether Datadog or vendor has published integration packages for your libraries; check [docs.datadoghq.com compatibility](https://docs.datadoghq.com/tracing/trace_collection/compatibility/go/).
Binary size and runtime span overhead will increase; measure impact in your environment.

When to avoid it — and what to weigh

Non-Go or Legacy Module Projects — Orchestrion only supports Go modules; projects using vendoring, GOPATH, or older Go versions (pre-1.20 not guaranteed) will not be compatible.
OpenTelemetry-Only or Multi-Vendor Observability — Orchestrion ships with Datadog tracer integrations by default. While vendor-agnostic in principle, using non-Datadog tracers requires alternate integration packages not described here; requires validation.
Build Pipeline Constraints — If your CI/CD forbids compile-time code generation, custom build hooks, or post-processing of source code, Orchestrion's approach will not fit.
Performance-Critical Lightweight Services — Compile-time instrumentation adds binary size and runtime overhead. If sub-millisecond latency and minimal footprint are non-negotiable, runtime sampling or no instrumentation may be preferable.

License & commercial use

Apache License 2.0 (Apache-2.0). Permissive OSI-approved license permitting commercial use, modification, and distribution with attribution and liability limitations.

Commercial use is permitted under Apache-2.0. Source code must be retained and license provided with distributions. Internal use (e.g., instrumentation for your own services) has no additional restrictions. Consult Datadog's terms if integrating with Datadog's commercial SaaS backend.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Strong
License clarity	Clear
Deployment complexity	Low
DEV.co fit	Good
Assessment confidence	High

Security considerations

Orchestrion performs source-code transformation during build; the tool itself must be trusted. Apache-2.0 license requires source availability. No explicit security audit data is provided. OpenSSF Scorecard badge linked but score not stated. Runtime instrumentation does not introduce authentication/encryption mechanisms; rely on Datadog backend security and network isolation for trace data.

Alternatives to consider

Manual dd-trace-go Integration

Add Datadog's dd-trace-go tracer directly in code with manual span creation. More verbose, but offers fine-grained control and avoids build-time dependency.

OpenTelemetry Go SDK + Instrumentation

Vendor-agnostic observability with auto-instrumentation packages for popular libraries. Requires runtime setup and may have different coverage vs. Orchestrion.

eBPF-based Observability (e.g., Pixie, Datadog's eBPF)

Zero-code instrumentation via kernel probes. Language-agnostic and no binary/build changes required, but limited to supported kernel versions and system calls.

Software development agency

Build on orchestrion with DEV.co software developers

Review the project documentation and compatibility matrix at datadoghq.dev/orchestrion. Run a pilot build with `orchestrion pin` to validate library support and performance impact in your environment.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

opentelemetry-go-instrumentation opentelemetry-go odigos

Related on DEV.co

Explore the category and the services that help you build with it.

Open-Source Observability Application Development DevOps & Monitoring API Development Talk to DEV.co

orchestrion FAQ

Does Orchestrion require a Datadog account?

Orchestrion is a local build tool; it does not require a Datadog account to run. However, the traces it produces must be shipped to an APM backend (Datadog's or another tracer's receiver) for storage and analysis.

Can I use Orchestrion with OpenTelemetry instead of Datadog?

Yes, Orchestrion is described as vendor-agnostic. However, the README notes that other vendors must provide alternate integrations; not all integrations are available for all vendors. Requires evaluation per use case.

What Go versions are supported?

Officially, the two latest Go releases (per Go's release policy). Older releases may work but are unsupported. Check your Go version with `go version`.

What happens if a library I use is not in Datadog's supported integrations?

Orchestrion will not automatically instrument it. You may need to add manual instrumentation via dd-trace-go or contribute an integration to the project.

Software development & web development with DEV.co

Adopting orchestrion is usually one piece of a larger software development effort. As a software development agency, DEV.co provides software development services and web development expertise — pairing senior software developers and web developers with your team to design, build, and operate open-source observability software in production.

Evaluate Orchestrion for Your Go Services

Talk to DEV.co Schedule a Consultation