Skip to content

Commit fa2e147

Browse files
jaegertracingbotjaegertracingbot
jaegertracingbot
and
jaegertracingbot
authored
Release 2.16.0 (#1070)
Release 2.16.0. This PR is created from CI and is part of the release process. Signed-off-by: jaegertracingbot <jaegertracingbot+jaeger-tracing@googlegroups.com> Co-authored-by: jaegertracingbot <jaegertracingbot+jaeger-tracing@googlegroups.com>
1 parent 861887f commit fa2e147

31 files changed

+3005
-5
lines changed

‎content/docs/v2/2.15/_index.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
---
22
title: Introduction
3-
linkTitle: 2.15 (latest)
3+
linkTitle: 2.15
44
weight: -215
55
children:
66
- title: Getting Started
@@ -9,7 +9,7 @@ children:
99
url: features
1010
sidebar_root_for: self
1111
aliases: [next-release-v2]
12-
cascade: { robots: true }
12+
cascade: { robots: false }
1313
---
1414

1515
Welcome to Jaeger's documentation! Below, you'll find information for beginners and experienced Jaeger users. If you cannot find what you are looking for, or have an issue not covered here, we'd love to [hear from you](/get-in-touch/).

‎content/docs/v2/2.16/_index.md‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
---
2+
title: Introduction
3+
linkTitle: 2.16 (latest)
4+
weight: -216
5+
children:
6+
- title: Getting Started
7+
url: getting-started
8+
- title: Features
9+
url: features
10+
sidebar_root_for: self
11+
aliases: [next-release-v2]
12+
cascade: { robots: true }
13+
---
14+
15+
Welcome to Jaeger's documentation! Below, you'll find information for beginners and experienced Jaeger users. If you cannot find what you are looking for, or have an issue not covered here, we'd love to [hear from you](/get-in-touch/).
16+
17+
## About
18+
19+
Jaeger is a distributed tracing platform released as open source by [Uber Technologies](http://uber.github.io) in 2016 and donated to [Cloud Native Computing Foundation](https://cncf.io/) where it is a graduated project.
20+
21+
With Jaeger you can:
22+
23+
* Monitor and troubleshoot distributed workflows
24+
* Identify performance bottlenecks
25+
* Track down root causes
26+
* Analyze service dependencies
27+
28+
### Learn More
29+
30+
If you are new to distributed tracing, we recommend the following external resources:
31+
* [Mastering Distributed Tracing (2019)](https://shkuro.com/books/2019-mastering-distributed-tracing/) by [Yuri Shkuro](https://shkuro.com), creator of Jaeger. The book provides in-depth coverage of many aspects of Jaeger design and operations, as well as distributed tracing in general.
32+
* [Take Jaeger for a HotROD ride](https://medium.com/jaegertracing/take-jaeger-for-a-hotrod-ride-233cf43e46c2), a step-by-step tutorial that demonstrates how to use Jaeger to solve application performance problems.
33+
* [Introducing Jaeger](https://www.shkuro.com/talks/2018-01-16-introducing-jaeger-1.0/), an (old) webinar that introduces Jaeger and its capabilities.
34+
* [Evolving Distributed Tracing at Uber](https://eng.uber.com/distributed-tracing/), a blog post that explains the history and reasons for the architectural choices made in Jaeger.
35+
36+
### Jaeger v2
37+
38+
(2024-11-12) Jaeger has had a successful 9 year history as the leading open source distributed tracing platform strongly aligned with industry standardization efforts such as OpenTracing and OpenTelemetry. Jaeger is one of the first graduated projects in the Cloud Native Computing Foundation (CNCF). After over 60 releases, Jaeger is celebrating a major milestone with the release of **Jaeger v2**. This is a new architecture that utilizes OpenTelemetry Collector framework as the base and extends it to implement Jaeger’s unique features. It brings significant improvements and changes, making Jaeger more flexible, extensible, and better aligned with the OpenTelemetry project. Read [full post here](https://medium.com/jaegertracing/jaeger-v2-released-09a6033d1b10).
39+
40+
Please refer to [Migration guide](./external-guides/migration/) for details on migrating from Jaeger v1.
41+
42+
## Features
43+
44+
* [OpenTracing](https://opentracing.io/)-inspired data model
45+
* [OpenTelemetry](https://opentelemetry.io/) compatible
46+
* Multiple built-in storage backends:
47+
* [Elasticsearch](./storage/elasticsearch/) and [OpenSearch](./storage/opensearch/)
48+
* [Cassandra](./storage/cassandra/)
49+
* [Badger](./storage/badger/) (single node, local file storage)
50+
* [Kafka](./storage/kafka/) (as an intermediate buffer)
51+
* [Memory storage](./storage/memory/)
52+
* Extensibility with custom backends via [Remote Storage API](./storage/#remote-storage)
53+
* System topology / service dependencies graphs
54+
* Adaptive sampling
55+
* Service Performance Monitoring (SPM)
56+
* Post-collection data processing
57+
58+
See [Features](./features/) page for more details.
59+
60+
### Relationship with OpenTelemetry
61+
62+
The Jaeger and [OpenTelemetry](https://opentelemetry.io) projects have different goals. OpenTelemetry aims to provide APIs and SDKs in multiple languages to allow applications to export various telemetry data out of the process, to any number of metrics and tracing backends. The Jaeger project is primarily the tracing backend that receives tracing telemetry data and provides processing, aggregation, data mining, and visualizations of that data. For more information please refer to a blog post [Jaeger and OpenTelemetry](https://medium.com/jaegertracing/jaeger-and-opentelemetry-1846f701d9f2).
63+
64+
Jaeger was originally designed to support the [OpenTracing standard](https://opentracing.io/specification/). The terminology is still used in Jaeger UI, but the concepts have direct mapping to the OpenTelemetry data model of traces.
65+
66+
| Capability | OpenTracing concept | OpenTelemetry concept |
67+
| ------------- | ------------------- | --------------------- |
68+
| Represent traces as directed acyclic graphs (not just trees) | [span references](https://github.com/opentracing/specification/blob/master/specification.md#references-between-spans) | [span links](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#span) |
69+
| Strongly typed span attributes | span tags | span attributes |
70+
| Strongly typed events/logs | span logs | span events |
71+
72+
## Quick Start
73+
74+
See [Getting Started](./getting-started/).
75+
76+
## Screenshots
77+
78+
### Traces View
79+
[![Traces View](/img/traces-ss.png)](/img/traces-ss.png)
80+
81+
### Trace Detail View
82+
[![Detail View](/img/trace-detail-ss.png)](/img/trace-detail-ss.png)
83+
84+
### Service Performance Monitoring View
85+
[![Service Performance Monitoring](/img/frontend-ui/spm.png)](/img/frontend-ui/spm.png)

‎content/docs/v2/2.16/architecture/_index.md‎

Lines changed: 143 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,143 @@
1+
---
2+
title: Architecture
3+
weight: 3
4+
children:
5+
- title: APIs
6+
url: apis
7+
- title: Sampling
8+
url: sampling
9+
- title: SPM
10+
url: spm
11+
- title: Terminology
12+
url: terminology
13+
---
14+
15+
Jaeger v2 is designed to be a versatile and flexible tracing platform. It can be deployed as a single binary that can be configured to perform different **roles** within the Jaeger architecture.
16+
17+
## Roles
18+
19+
* **collector**: Receives incoming trace data from applications and writes it into a storage backend.
20+
* **query**: Serves the APIs and the user interface for querying and visualizing traces.
21+
* **ingester**: Ingests spans from Kafka and writes them into a storage backend; useful when running in a [split collector-Kafka-ingester configuration](#via-kafka).
22+
* **all-in-one**: Collector and query roles in a single process.
23+
* **agent**: A host agent or a sidecar that runs next to the application and forwards trace data to the collector. While Jaeger can be configured for this role, we recommend using the standard [OpenTelemetry Collector](https://opentelemetry.io/docs/collector/) instead because you may likely need it to process other types of telemetry (metrics & logs).
24+
25+
Choosing between the **all-in-one** and the **collector**/**query** configurations is a matter of preference. When using external storage backend, both configurations are horizontally scalable, but the **collector**/**query** configuration allows to separate the read and write traffic and to scale them independently, as well as to apply different access and security policies.
26+
27+
The **all-in-one** configuration with in-memory storage is most suitable for development and testing, but it is not recommended for production since the data is lost on restarts. **all-in-one** with the [Badger](../storage/badger/) backend _can_ be used in production, but only for modest data volumes since it is limited to a single instance and cannot be scaled horizontally.
28+
29+
## Architecture choices
30+
31+
The two most common deployment options for a scalable Jaeger backend are direct-to-storage and using Kafka as a buffer.
32+
33+
### Direct to storage
34+
35+
In this deployment the **collector**s receive the data from traced applications and write it directly to storage. The storage must be able to handle both average and peak traffic. The **collector**s may use an in-memory queue to smooth short-term traffic peaks, but a sustained traffic spike may result in dropped data if the storage is not able to keep up.
36+
37+
[![Architecture](/img/architecture-v2-2024.png)](/img/architecture-v2-2024.png)
38+
39+
### Via Kafka
40+
41+
To prevent data loss between **collector**s and storage, Kafka can be used as an intermediary, persistent queue. The **collector**s are configured with Kafka exporters. An additional component, **ingester**, needs to be deployed to read data from Kafka and save it to storage. Multiple **ingester**s can be deployed to scale up ingestion; they will automatically partition the load across them. In practice, an **ingester** is very similar to a **collector**, only configured with a Kafka receiver instead of RPC-based receivers.
42+
43+
[![Architecture](/img/architecture-v2-kafka-2024.png)](/img/architecture-v2-kafka-2024.png)
44+
45+
## With OpenTelemetry Collector
46+
47+
You **do not need** to use the OpenTelemetry Collector to operate Jaeger, because Jaeger is a customized distribution of the OpenTelemetry Collector with different roles. However, if you already use the OpenTelemetry Collectors, for gathering other types of telemetry or for pre-processing / enriching the tracing data, it can be placed _in front of_ Jaeger in the collection pipeline. The OpenTelemetry Collectors can be run as an application sidecar, as a host agent / daemon, or as a remote service cluster.
48+
49+
The OpenTelemetry Collector supports Jaeger's Remote Sampling protocol and can either serve static configurations from config files directly, or proxy the requests to the Jaeger backend (e.g., when using adaptive sampling).
50+
51+
[![Architecture](/img/architecture-v2-otel.png)](/img/architecture-v2-otel.png)
52+
53+
### OpenTelemetry Collector as a sidecar / host agent
54+
55+
Benefits:
56+
57+
* The SDK configuration is simplified as both trace export endpoint and sampling config endpoint can point to a local host and not worry about discovering where those services run remotely.
58+
* Collector may provide data enrichment by adding environment information, like k8s pod name.
59+
* Resource usage for data enrichment can be distributed across all application hosts.
60+
61+
Downsides:
62+
63+
* An extra layer of marshaling/unmarshaling the data.
64+
65+
### OpenTelemetry Collector as a remote cluster
66+
67+
Benefits:
68+
* Sharding capabilities, e.g., when using [tail-based sampling](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/tailsamplingprocessor/README.md).
69+
70+
Downsides:
71+
72+
* An extra layer of marshaling/unmarshaling the data.
73+
74+
## Jaeger Binary
75+
76+
The Jaeger binary is build on top of the OpenTelemetry Collector framework and includes:
77+
* Official upstream components, such as OTLP Receiver, Batch and Attribute Processor, etc.
78+
* Upstream components from `opentelemetry-collector-contrib`, such as Kafka Exporter and Receiver, Tail Sampling Processor, etc.
79+
* Jaeger own components, such as Jaeger Storage Exporter, Jaeger Query Extension, etc.
80+
81+
[![Architecture](/img/architecture-v2-binary.png)](/img/architecture-v2-binary.png)
82+
83+
### Jaeger Components
84+
85+
* [Jaeger Storage Extension](https://github.com/jaegertracing/jaeger/tree/v2.16.0/cmd/jaeger/internal/extension/jaegerstorage) - Extensible hub for storage backends supported in Jaeger. It provides all other Jaeger components access to Jaeger storage implementations.
86+
87+
* [Jaeger Storage Exporter](https://github.com/jaegertracing/jaeger/tree/v2.16.0/cmd/jaeger/internal/extension/jaegerstorage) - Writes spans to storage backend configured in the Jaeger Storage Extension.
88+
89+
* [Jaeger Query Extension](https://github.com/jaegertracing/jaeger/tree/v2.16.0/cmd/jaeger/internal/extension/jaegerquery) - Run the query APIs and the Jaeger UI.
90+
91+
* [Adaptive Sampling Processor](https://github.com/jaegertracing/jaeger/tree/v2.16.0/cmd/jaeger/internal/processors/adaptivesampling) - Performs probabilities calculations for [adaptive sampling](./sampling/#adaptive-sampling).
92+
93+
* [Remote Sampling Extension](https://github.com/jaegertracing/jaeger/tree/v2.16.0/cmd/jaeger/internal/extension/remotesampling) - Serves the endpoints for [Remote Sampling](./sampling/#remote-sampling), based on static configuration file or [adaptive sampling](./sampling/#adaptive-sampling).
94+
95+
### OpenTelemetry Components
96+
97+
#### Receivers
98+
99+
* [OTLP](https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver) - Accepts spans sent via OpenTelemetry Protocol (OTLP).
100+
101+
* [Jaeger](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/jaegerreceiver) - Accepts Jaeger formatted traces transported via gRPC or Thrift protocols.
102+
103+
* [Kafka](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/kafkareceiver) - Accepts spans from Kafka in various formats (OTLP, Jaeger, Zipkin).
104+
105+
* [Zipkin](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/zipkinreceiver) - Accepts spans using Zipkin v1 and v2 protocols.
106+
107+
* [No-op](https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/nopreceiver) - Used for Jaeger UI / query service deployment that does not require an ingestion pipeline.
108+
109+
#### Processors
110+
* [Batch Processor](https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/batchprocessor) - Batches spans for better efficiency.
111+
112+
* [Tail Sampling](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/tailsamplingprocessor) - Supports advanced post-collection sampling.
113+
114+
* [Memory Limiter](https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/memorylimiterprocessor) - Supports back-pressure when the collector is overloaded.
115+
116+
* [Attributes Processor](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/attributesprocessor) - Allows filtering, rewriting, and enriching spans with attributes. Can be used to redact sensitive data, reduce data volume, or attach environment information.
117+
118+
* [Filter Processor](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/filterprocessor) - Allows dropping spans and span events from the collector (⚠️ may cause broken traces).
119+
120+
#### Exporters
121+
* [OTLP](https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/otlpexporter) - Send data in OTLP format via gRPC.
122+
123+
* [OTLP HTTP](https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/otlphttpexporter) - Sends data in OTLP format over HTTP.
124+
125+
* [Kafka](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/kafkaexporter/) - Sends data to Kafka in various formats (OTLP, Jaeger, Zipkin).
126+
127+
* [Prometheus](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/prometheusexporter) - Sends metrics to Prometheus.
128+
129+
* [Debug](https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/debugexporter) - Debugging tool for pipelines.
130+
131+
* [No-op](https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/nopexporter) - Used for Jaeger UI / query service deployment that does not require an ingestion pipeline.
132+
133+
#### Connectors
134+
* [Span Metrics](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/connector/spanmetricsconnector/) - Generates metrics from span data.
135+
136+
* [Forward](https://github.com/open-telemetry/opentelemetry-collector/blob/main/connector/forwardconnector/) - Redirects telemetry between pipelines in the collector (ex: span to metric / span to log)
137+
138+
#### Extensions
139+
* [Health Check v2](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/healthcheckv2extension) - Supports health checks.
140+
141+
* [zPages](https://github.com/open-telemetry/opentelemetry-collector/tree/main/extension/zpagesextension) - Exposes internal state of the collector for debugging.
142+
143+
* [Performance Profiler (pprof)](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/pprofextension) - enables Go's `net/http/pprof` endpoint, typically used by developers to collect performance profiles and investigate issues with the collector.

0 commit comments

Comments
 (0)