---
title: "OpenTelemetry in Alloy | Grafana Alloy documentation"
description: "Learn about the OpenTelemetry Engine, a bundled OpenTelemetry Collector distribution embedded within Grafana Alloy"
---

> For a curated documentation index, see [llms.txt](/llms.txt). For the complete documentation index, see [llms-full.txt](/llms-full.txt).

# OpenTelemetry in Alloy

Grafana Alloy combines the Prometheus-native, production-grade collection features of Alloy with the broad ecosystem and standards of OpenTelemetry. The Alloy OpenTelemetry Engine is an OpenTelemetry Collector distribution embedded within Alloy. It lets you run Alloy with the OpenTelemetry Collector while retaining access to Alloy features and integrations through the Alloy Engine extension.

> **EXPERIMENTAL**: OTel Engine is an [experimental](/docs/release-life-cycle/) feature. Experimental features are subject to frequent breaking changes, and may be removed with no equivalent replacement.
> 
> To maintain full compatibility of the OTel Engine with the upstream OpenTelemetry Collector and expose a compatible command line interface, the OTel Engine isn’t hidden behind a stability [flag](/docs/alloy/latest/reference/cli/run/).
> 
> Make sure that you understand the risks involved before using an experimental feature in your production environments.

## Why the OTel Engine exists

Standard OpenTelemetry Collector pipelines use YAML configuration, but Alloy components require translating that configuration into Alloy syntax. The OTel Engine runs the Collector runtime directly, so you can use Collector YAML configurations without translation.

The OTel Engine addresses this by running the upstream Collector runtime directly from the Alloy executable. You can bring existing Collector configurations to Alloy, use familiar Collector tooling, and choose from the [components bundled with the `otel` command](../../reference/cli/otel/#included-components).

The OTel Engine also gives Grafana a standards-native foundation for extending Alloy. Grafana is committed to providing a first-class OpenTelemetry collection experience as this experimental engine matures.

## How the engines fit together

Both engines are built into the same Alloy binary: `alloy run` starts the Default Engine, and `alloy otel` starts the OTel Engine. The optional Alloy Engine extension lets you run a Default Engine pipeline inside the OTel Engine, in the same process.

The following diagram shows how the engines and the extension fit inside the Alloy executable:

```
---
config:
  flowchart:
    subGraphTitleMargin:
      top: 10
      bottom: 10
    rankSpacing: 10
---

flowchart TD
    subgraph EXEC["Grafana Alloy executable"]
        direction TB
        run(["'alloy run' command"])
        otel(["'alloy otel' command"])
        DE["Default Engine
Traditional Alloy pipeline"]
        run --> DE

        subgraph OE["OTel Engine"]
            direction TB
            subgraph EXT["alloyengine extension (optional)"]
                DEP["Default Engine
Traditional Alloy pipeline"]
            end
        end
        otel --> OE
    end

    style EXEC fill:#fdefe5,stroke:#000000,color:#000000,rx:10,ry:10
    style OE fill:#cce5ff,stroke:#000000,color:#000000,rx:10,ry:10
    style EXT fill:#cce5ff,stroke:#000000,color:#000000,stroke-dasharray: 4 3,rx:10,ry:10
    style DE fill:#ff8833,stroke:#000000,color:#000000,rx:10,ry:10
    style DEP fill:#ff8833,stroke:#000000,color:#000000,rx:10,ry:10
    style run fill:#ffffff,stroke:#000000,color:#000000,rx:10,ry:10
    style otel fill:#ffffff,stroke:#000000,color:#000000,rx:10,ry:10
```

## Choose an engine

Alloy supports two runtime engines and an extension. Choose the engine that best matches your existing configuration and collection workload.

- **Default Engine**: The standard way to run Alloy. It uses [Alloy configuration syntax](../../get-started/syntax/) and Alloy components. It remains the stable, most polished experience for getting the most from Grafana Cloud, with [backward compatibility](../backward-compatibility/) guarantees, a built-in UI, live debugging, support bundles, clustering, and broad Grafana integrations.
- **OTel Engine**: The upstream OpenTelemetry Collector runtime embedded in Alloy. It uses [Collector YAML configuration](https://opentelemetry.io/docs/collector/configuration/) and standard Collector command-line arguments. It provides a direct path for OpenTelemetry-native pipelines and existing Collector configurations.
- **Alloy Engine extension**: An OpenTelemetry Collector extension that starts a Default Engine pipeline alongside the OTel Engine. The two pipelines run in the same process, but they don’t interact directly.

### Use the OTel Engine for OpenTelemetry-native pipelines

The OTel Engine is a good fit when you:

- Already run an OpenTelemetry Collector and want to reuse its YAML configuration and operational model.
- Prefer to use standard Collector configuration and command-line arguments.
- Collect push-based, OpenTelemetry-native signals through OTLP.
- Use Grafana Application Observability and don’t need Default Engine components in the same pipeline.

Grafana Application Observability uses OpenTelemetry-native telemetry. To build a compatible Collector pipeline, refer to [Set up OpenTelemetry Collector for Application Observability](/docs/opentelemetry/collector/opentelemetry-collector/).

### Use the Default Engine for the full Alloy experience

The Default Engine is the recommended choice when you:

- Want the stable and most complete Alloy experience.
- Collect infrastructure telemetry with Prometheus exporters and pull-based scrapes.
- Need Alloy features such as clustering, the built-in UI, live debugging, support bundles, or configuration reloads.
- Use Grafana integrations for Kubernetes monitoring, Database Observability, eBPF, logs, or profiles.

The Default Engine is optimized for Prometheus pipelines and label semantics. It also provides Grafana-specific collection features that don’t yet have OpenTelemetry-native equivalents.

### Run both engines when you need both component sets

Use the `alloyengine` extension when one process needs both standard Collector components and Default Engine components. This approach can simplify small deployments.

For large workloads, run the engines in separate processes so you can scale and troubleshoot them independently. Push-based OTLP gateways and pull-based Prometheus scrapers have different load and scaling characteristics.

## Manage the OTel Engine with Fleet Management

The OTel Engine works with the OpenTelemetry Collector support in Grafana Fleet Management. The Alloy container provides an `otelcol`-compatible entry point, and the engine includes the components needed to run with the Open Agent Management Protocol (OpAMP) Supervisor. To monitor and remotely configure an OTel Engine deployment, follow the [Fleet Management setup for the OpenTelemetry Collector](/docs/grafana-cloud/send-data/fleet-management/get-started/opentelemetry-collector/).

## How the engines evolve

Grafana continues to improve the OTel Engine and its integration with Grafana products. The goal is a first-class collection experience for users who choose standard OpenTelemetry Collector workflows.

Default Engine continues to be in active development. It remains the default, stable engine, and Grafana continues to add features to it. The two engines can evolve toward the same outcomes without requiring every feature to have an identical implementation.

## Next steps

- [Set up the OTel Engine](../../set-up/otel_engine/).
- [Explore the `otel` command and its included components](../../reference/cli/otel/).