OTel 收集器与导出器

The OpenTelemetry Collector is a powerful, vendor-agnostic proxy that receives, processes, and exports observability data. Think of it as a central traffic controller for your logs, metrics, and traces.

It simplifies managing your observability data, especially in complex distributed systems, by acting as an intermediary.

Instead of sending observability data directly from every application to different backend systems, the Collector acts as an intermediary. This offers several benefits:

• Reduced Overhead: Applications send data once to the Collector.
• Centralized Processing: Apply common transformations in one place.
• Backend Flexibility: Easily switch or add observability backends without changing application code.

The OpenTelemetry Collector is built from several key components, each with a specific job. Understanding these parts helps you configure it effectively:

• Receivers: How data gets IN.
• Processors: How data is TRANSFORMED.
• Exporters: How data gets OUT.
• Service: Orchestrates these components to form pipelines.

Let's look at each one individually.

Receivers are the entry points for observability data into the Collector. They listen for data in various formats and protocols.

Think of a receiver as a data intake funnel. It's configured to accept traces, metrics, or logs from your applications, infrastructure, or other sources.

The most common receiver is the OTLP receiver. OTLP stands for OpenTelemetry Protocol, which is the native format for OpenTelemetry data.

Here's how you might configure an OTLP receiver to listen for both gRPC and HTTP data:

Processors manipulate the observability data between being received and before being exported. They can enrich, filter, aggregate, or modify data.

This is where you can optimize data, reduce noise, add useful context, or even sample data to control volume.

A very common processor is the batch processor. It groups data points (traces, metrics, or logs) together before sending them to an exporter.

Batching reduces network calls and can significantly improve performance and resource usage for both the Collector and the backend systems.

Exporters are responsible for sending the processed observability data from the Collector to one or more backend systems. These backends could be a tracing system, a metrics database, or a log management platform.

The Collector supports a wide variety of exporters for different vendors and open-source tools.

Just like receivers, there's also an OTLP exporter. This allows the Collector to forward data, in OpenTelemetry's native format, to another OTLP-compatible endpoint.

This is useful for chaining Collectors or sending data to a vendor's OTLP endpoint.

Here's how you'd define a simple pipeline in the Collector's configuration file, connecting a receiver, a processor, and an exporter.

The service section ties everything together, defining which receivers, processors, and exporters are used for traces, metrics, and logs.

Let's test your knowledge about the OpenTelemetry Collector's components.

You've learned that the OpenTelemetry Collector is a crucial component for managing observability data.

• It acts as a central hub, decoupling applications from observability backends.
• It uses Receivers to get data in, Processors to transform it, and Exporters to send it out.
• This architecture provides flexibility, reduces overhead, and allows for centralized data manipulation.

Next, we'll get an overview of how to instrument your applications using OpenTelemetry SDKs!