Odigos Components

​

Goals

Odigos acts as a control plane for all the observability needs in a Kubernetes cluster. It is responsible for:

• Automatic instrumentation of applications
• Automatic configuration and deployment of collectors
• Infrastructure observability (Kubernetes nodes, databases, etc)

Odigos achieves its goals by deploying a set of components that work together to collect, process, and export telemetry data.

​

High Level Architecture

​

Component types:

• Kubernetes Operators - reconcile the desired state of cluster resources and deploy / configure the necessary components.
• DaemonSets - perform node-level tasks, such as interacting with a process running on the node OS, accessing the Kubelet, and reading logs from the node filesystem.
• Deployments - run cluster-level components like the OpenTelemetry Collector and the Odigos UI.

​

Component Segments

Odigos is divided into three main segments:

• Instrumentation

  • Inject OpenTelemetry agents to collect the instrumentation data from Odigos sources (instrumented applications)
  • Record and report runtime information from the process environment that is relevant to instrumentation
  • Export collected telemetry to the pipeline.

• Pipeline

  • Offload common or heavy tasks from the instrumented application runtime
  • Apply Odigos Actions on the telemetry data
  • Batch and send the telemetry data to the configured destinations

• Odigos Management

  • orchestrate the pipeline and the instrumentation based on the user’s configuration and cluster state,
  • provide a UI for the odigos control plane.

​

Pipeline

​

Auto Scaler (Pipeline Manager)

Type: Auto scaler is a Kubernetes operator

K8s Resource: kubectl get deployments -n odigos-system odigos-autoscaler

Role: The auto scaler component is responsible for managing the OpenTelemetry Collectors which implement the OpenTelemetry pipeline.

• Start and stop Collectors when needed (e.g. when sources or destinations are added or removed).
• Schedule the node collector to start only after the cluster collector is ready.
• Generate the configuration for the Collectors based on Odigos sources, destinations, and Actions.

​

Cluster Collector (Gateway Collector)

Type: Cluster collector is a deployment of the OpenTelemetry collector

K8s Resource: kubectl get deployments -n odigos-system odigos-gateway

Role: The cluster collector receives and processes all telemetry collected in the cluster, applies Actions, and exports data to the configured destinations.

• Batch telemetry data for better performance and export it to the configured destinations
• Modify the telemetry data based on the Odigos Actions.
• Apply tail sampling based on the Odigos Actions to reduce the volume of data sent to the destinations.
• Collect metrics about the entities and report it to the UI for monitoring.
• Offload tasks from the agents, to reduce the overhead on the workload runtime environment
• Centralize any common processing that can be shared across multiple agents.

​

Node Collector

Type: Node collector is a daemon set and will run one pod per node in the cluster

K8s Resource: kubectl get daemonsets -n odigos-system odigos-data-collection

Role: The Node Collector (in the context of Pipeline component) receives telemetry data from agents running on the node, enriches it with node-level attributes, and forward it efficiently and reliably to the cluster collector.

• Receive telemetry data from agents running on the node (Odiglet for eBPF based agents, and instrumentation processes for native OpenTelemetry agents).
• Add node-level attributes to the telemetry data (k8s.node.name, cloud attributes, etc).
• Batch and send telemetry data to the Cluster Collector, offloading any network overhead from the instrumented application runtime.

​

Instrumentation

​

Instrumentor (Auto Instrumentation Agent Manager)

Type: Instrumentor is a Kubernetes operator

K8s Resource: kubectl get deployments -n odigos-system odigos-instrumentor

Role: The Instrumentor is responsible for managing auto instrumentation agents which collect telemetry data from Odigos sources.

• Create and manage instrumentationconfig.odigos.io objects
  • Trigger Odiglet to inspect runtime information of workloads.
  • Trigger Scheduler to deploy the Odigos pipeline.
  • Merge Odigos instrumentation rules and config to a workload scope configuration for the agent.
• Inject the instrumentation device into the workload manifest resource as virtual device.
• Monitor the source.odigos.io CRD and cleanup any instrumentation related resources when a source is removed.

​

Odiglet

Type: Odiglet is a daemon set and will run one pod per node in the cluster

K8s Resource: kubectl get daemonsets -n odigos-system odiglet

Role: Odiglet sets up the node environment to run telemetry collection agents.

• Inspect container runtime details of instrumented sources (to determine programming language, relevant environment variables, runtime versions, etc).
• Implement the Kubernetes virtual instrumentation devices. In the presence of a supported device on the pod, Odiglet will mount the agent code from file system to the pod and add the relevant environment variables to initiate instrumentation.
• For eBPF-based instrumentation, Odiglet will inject the eBPF code into the pod, pick up telemetry from eBPF, and push it downstream to the Node Collector.
• Monitor for config changes to instrumentations and update the relevant agents accordingly at runtime.

​

Node Collector

Role: Node collector (in the context of instrumentation) is responsible for scraping Kubernetes metrics, and collect logs from the node filesystem.

• When a metrics destination exists, the node collector will use the OpenTelemetry Collector “kubeletstats receiver” to scrape k8s related metrics from the Kubelet and export them as OpenTelemetry metrics to the cluster collector.
• When a logs destination exists, the node collector will use the OpenTelemetry Collector “filelog receiver” to read the relevant pod logs from the node filesystem and export them as OpenTelemetry logs to the cluster collector.

​

Odigos

​

Odigos UI

Type: Odigos UI is a web application backed by a deployment in the cluster and accessible by the user’s browser.

K8s Resource: kubectl get deployments -n odigos-system odigos-ui

Role: The Odigos UI is a web application that allows users to configure various aspects of the Odigos installation.

• Serve as web server for the Odigos UI
  • Serve static files to the frontend
  • Provide a GraphQL API for the frontend, which in turn interacts with Kubernetes API to manage the Odigos installation.
• Provide a user interface for monitoring and managing the Odigos installation, including the sources, destinations, actions, and instrumentation rules.
• Examine the current state of Odigos and show any errors.

​

Scheduler

Type: Scheduler is a Kubernetes operator

K8s Resource: kubectl get deployments -n odigos-system odigos-scheduler

Role: The scheduler is responsible for managing the Odigos installation itself.

• Monitor the Odigos sources and destinations to trigger deployment of the Odigos pipeline.
• Reconcile Odigos configuration to run validations, set defaults, and apply Odigos Profiles (configuration presets) to the cluster.