From a36d03487dfc1cea2fe6a6415efb845b0be6ec38 Mon Sep 17 00:00:00 2001 From: Yuri Shkuro Date: Sat, 14 Sep 2024 23:12:33 -0400 Subject: [PATCH 1/4] Use fully qualified Docker image version Signed-off-by: Yuri Shkuro --- scripts/gen-cli-data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/gen-cli-data.py b/scripts/gen-cli-data.py index a29105a4..cefc7f63 100644 --- a/scripts/gen-cli-data.py +++ b/scripts/gen-cli-data.py @@ -34,7 +34,7 @@ def generate(tool, **kwargs): volume = f'{output_path}/data/cli/{jaeger_ver}:/data' docker_img = 'all-in-one' if tool == 'jaeger-all-in-one' else tool - docker_image = f"jaegertracing/{docker_img}:{jaeger_ver}" + docker_image = f"jaegertracing/{docker_img}:{jaeger_ver}.0" cmd = " ".join([ "docker run", From 9b9d0440e941db28fb0c4705b5d92847d05a3dec Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sat, 14 Sep 2024 23:17:32 -0400 Subject: [PATCH 2/4] Release release-1.61.0 (#737) Release release-1.61.0. This PR is created from CI and is part of the release process. Signed-off-by: jaegertracingbot Co-authored-by: jaegertracingbot --- config.toml | 6 +- content/docs/1.61/_index.md | 78 + content/docs/1.61/apis.md | 144 ++ content/docs/1.61/architecture.md | 125 ++ content/docs/1.61/cli.md | 13 + content/docs/1.61/deployment.md | 718 ++++++++ content/docs/1.61/external-guides.md | 38 + content/docs/1.61/faq.md | 71 + content/docs/1.61/features.md | 77 + content/docs/1.61/frontend-ui.md | 265 +++ content/docs/1.61/getting-started.md | 147 ++ content/docs/1.61/monitoring.md | 48 + content/docs/1.61/operator.md | 1461 +++++++++++++++++ content/docs/1.61/performance-tuning.md | 116 ++ content/docs/1.61/sampling.md | 99 ++ content/docs/1.61/security.md | 52 + content/docs/1.61/spm.md | 374 +++++ content/docs/1.61/tools.md | 29 + content/docs/1.61/troubleshooting.md | 140 ++ content/docs/1.61/windows.md | 43 + data/cli/1.61/config.json | 56 + data/cli/1.61/jaeger-agent.yaml | 143 ++ data/cli/1.61/jaeger-agent_completion.yaml | 16 + data/cli/1.61/jaeger-agent_docs.yaml | 17 + data/cli/1.61/jaeger-agent_status.yaml | 16 + data/cli/1.61/jaeger-agent_version.yaml | 11 + data/cli/1.61/jaeger-all-in-one-badger.yaml | 490 ++++++ .../cli/1.61/jaeger-all-in-one-cassandra.yaml | 613 +++++++ .../1.61/jaeger-all-in-one-elasticsearch.yaml | 755 +++++++++ data/cli/1.61/jaeger-all-in-one-memory.yaml | 463 ++++++ .../1.61/jaeger-all-in-one-prometheus.yaml | 511 ++++++ data/cli/1.61/jaeger-all-in-one.yaml | 463 ++++++ .../1.61/jaeger-all-in-one_completion.yaml | 16 + data/cli/1.61/jaeger-all-in-one_docs.yaml | 17 + data/cli/1.61/jaeger-all-in-one_env.yaml | 11 + .../1.61/jaeger-all-in-one_print-config.yaml | 17 + data/cli/1.61/jaeger-all-in-one_status.yaml | 16 + data/cli/1.61/jaeger-all-in-one_version.yaml | 11 + data/cli/1.61/jaeger-collector-adaptive.yaml | 482 ++++++ data/cli/1.61/jaeger-collector-cassandra.yaml | 455 +++++ .../1.61/jaeger-collector-elasticsearch.yaml | 597 +++++++ data/cli/1.61/jaeger-collector-file.yaml | 455 +++++ data/cli/1.61/jaeger-collector-kafka.yaml | 399 +++++ data/cli/1.61/jaeger-collector.yaml | 455 +++++ .../cli/1.61/jaeger-collector_completion.yaml | 16 + data/cli/1.61/jaeger-collector_docs.yaml | 17 + data/cli/1.61/jaeger-collector_env.yaml | 11 + .../1.61/jaeger-collector_print-config.yaml | 17 + data/cli/1.61/jaeger-collector_status.yaml | 16 + data/cli/1.61/jaeger-collector_version.yaml | 11 + data/cli/1.61/jaeger-ingester-cassandra.yaml | 311 ++++ .../1.61/jaeger-ingester-elasticsearch.yaml | 453 +++++ data/cli/1.61/jaeger-ingester.yaml | 311 ++++ data/cli/1.61/jaeger-ingester_completion.yaml | 16 + data/cli/1.61/jaeger-ingester_docs.yaml | 17 + data/cli/1.61/jaeger-ingester_env.yaml | 11 + .../1.61/jaeger-ingester_print-config.yaml | 17 + data/cli/1.61/jaeger-ingester_status.yaml | 16 + data/cli/1.61/jaeger-ingester_version.yaml | 11 + data/cli/1.61/jaeger-query-cassandra.yaml | 303 ++++ data/cli/1.61/jaeger-query-elasticsearch.yaml | 445 +++++ data/cli/1.61/jaeger-query-prometheus.yaml | 351 ++++ data/cli/1.61/jaeger-query.yaml | 303 ++++ data/cli/1.61/jaeger-query_completion.yaml | 16 + data/cli/1.61/jaeger-query_docs.yaml | 17 + data/cli/1.61/jaeger-query_env.yaml | 11 + data/cli/1.61/jaeger-query_print-config.yaml | 17 + data/cli/1.61/jaeger-query_status.yaml | 16 + data/cli/1.61/jaeger-query_version.yaml | 11 + 69 files changed, 13267 insertions(+), 3 deletions(-) create mode 100644 content/docs/1.61/_index.md create mode 100644 content/docs/1.61/apis.md create mode 100644 content/docs/1.61/architecture.md create mode 100644 content/docs/1.61/cli.md create mode 100644 content/docs/1.61/deployment.md create mode 100644 content/docs/1.61/external-guides.md create mode 100644 content/docs/1.61/faq.md create mode 100644 content/docs/1.61/features.md create mode 100644 content/docs/1.61/frontend-ui.md create mode 100644 content/docs/1.61/getting-started.md create mode 100644 content/docs/1.61/monitoring.md create mode 100644 content/docs/1.61/operator.md create mode 100644 content/docs/1.61/performance-tuning.md create mode 100644 content/docs/1.61/sampling.md create mode 100644 content/docs/1.61/security.md create mode 100644 content/docs/1.61/spm.md create mode 100644 content/docs/1.61/tools.md create mode 100644 content/docs/1.61/troubleshooting.md create mode 100644 content/docs/1.61/windows.md create mode 100644 data/cli/1.61/config.json create mode 100644 data/cli/1.61/jaeger-agent.yaml create mode 100644 data/cli/1.61/jaeger-agent_completion.yaml create mode 100644 data/cli/1.61/jaeger-agent_docs.yaml create mode 100644 data/cli/1.61/jaeger-agent_status.yaml create mode 100644 data/cli/1.61/jaeger-agent_version.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one-badger.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one-cassandra.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one-elasticsearch.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one-memory.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one-prometheus.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one_completion.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one_docs.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one_env.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one_print-config.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one_status.yaml create mode 100644 data/cli/1.61/jaeger-all-in-one_version.yaml create mode 100644 data/cli/1.61/jaeger-collector-adaptive.yaml create mode 100644 data/cli/1.61/jaeger-collector-cassandra.yaml create mode 100644 data/cli/1.61/jaeger-collector-elasticsearch.yaml create mode 100644 data/cli/1.61/jaeger-collector-file.yaml create mode 100644 data/cli/1.61/jaeger-collector-kafka.yaml create mode 100644 data/cli/1.61/jaeger-collector.yaml create mode 100644 data/cli/1.61/jaeger-collector_completion.yaml create mode 100644 data/cli/1.61/jaeger-collector_docs.yaml create mode 100644 data/cli/1.61/jaeger-collector_env.yaml create mode 100644 data/cli/1.61/jaeger-collector_print-config.yaml create mode 100644 data/cli/1.61/jaeger-collector_status.yaml create mode 100644 data/cli/1.61/jaeger-collector_version.yaml create mode 100644 data/cli/1.61/jaeger-ingester-cassandra.yaml create mode 100644 data/cli/1.61/jaeger-ingester-elasticsearch.yaml create mode 100644 data/cli/1.61/jaeger-ingester.yaml create mode 100644 data/cli/1.61/jaeger-ingester_completion.yaml create mode 100644 data/cli/1.61/jaeger-ingester_docs.yaml create mode 100644 data/cli/1.61/jaeger-ingester_env.yaml create mode 100644 data/cli/1.61/jaeger-ingester_print-config.yaml create mode 100644 data/cli/1.61/jaeger-ingester_status.yaml create mode 100644 data/cli/1.61/jaeger-ingester_version.yaml create mode 100644 data/cli/1.61/jaeger-query-cassandra.yaml create mode 100644 data/cli/1.61/jaeger-query-elasticsearch.yaml create mode 100644 data/cli/1.61/jaeger-query-prometheus.yaml create mode 100644 data/cli/1.61/jaeger-query.yaml create mode 100644 data/cli/1.61/jaeger-query_completion.yaml create mode 100644 data/cli/1.61/jaeger-query_docs.yaml create mode 100644 data/cli/1.61/jaeger-query_env.yaml create mode 100644 data/cli/1.61/jaeger-query_print-config.yaml create mode 100644 data/cli/1.61/jaeger-query_status.yaml create mode 100644 data/cli/1.61/jaeger-query_version.yaml diff --git a/config.toml b/config.toml index ef435cbf..74e55fe9 100644 --- a/config.toml +++ b/config.toml @@ -25,9 +25,9 @@ home = [ "HTML", "JSON", "REDIRECTS" ] mediumhandle = "jaegertracing" opengraphimage = "img/jaeger-icon-color.png" - latest = "1.60" - binariesLatest = "1.60.0" - versions = ["1.60","1.59","1.58","1.57","1.56","1.55","1.54","1.53","1.52","1.51","1.50","1.49","1.48","1.47","1.46","1.45","1.44","1.43","1.42","1.41","1.40","1.39","1.38","1.37","1.36","1.35","1.34","1.33","1.32"] + latest = "1.61" + binariesLatest = "1.61.0" + versions = ["1.61","1.60","1.59","1.58","1.57","1.56","1.55","1.54","1.53","1.52","1.51","1.50","1.49","1.48","1.47","1.46","1.45","1.44","1.43","1.42","1.41","1.40","1.39","1.38","1.37","1.36","1.35","1.34","1.33","1.32"] [navbar] [[links]] diff --git a/content/docs/1.61/_index.md b/content/docs/1.61/_index.md new file mode 100644 index 00000000..e63ac369 --- /dev/null +++ b/content/docs/1.61/_index.md @@ -0,0 +1,78 @@ +--- +title: Introduction +weight: 1 +children: +- title: Features + url: features +--- + +Welcome to Jaeger's documentation portal! 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). + +If you are new to distributed tracing, please take a look at the [Related Links](#related-links) section below. + +## About + +Jaeger is a distributed tracing platform released as open source by [Uber Technologies][ubeross]. +With Jaeger you can: + +* Monitor and troubleshoot distributed workflows +* Identify performance bottlenecks +* Track down root causes +* Analyze service dependencies + +Uber published a blog post, [Evolving Distributed Tracing at Uber](https://eng.uber.com/distributed-tracing/), where they explain the history and reasons for the architectural choices made in Jaeger. [Yuri Shkuro](https://shkuro.com), creator of Jaeger, also published a book [Mastering Distributed Tracing](https://shkuro.com/books/2019-mastering-distributed-tracing/) that covers in-depth many aspects of Jaeger design and operation, as well as distributed tracing in general. + +## Features + + * [OpenTracing](https://opentracing.io/)-inspired data model + * [OpenTelemetry](https://opentelemetry.io/) compatible + * Multiple built-in storage backends: Cassandra, Elasticsearch and in-memory + * Community supported external storage backends via the gRPC plugin: [ClickHouse](https://github.com/jaegertracing/jaeger-clickhouse) + * System topology graphs + * Adaptive sampling + * Service Performance Monitoring (SPM) + * Post-collection data processing + +See [Features](./features/) page for more details. + +## Technical Specs + + * Backend components implemented in Go + * React/Javascript UI + * Supported storage backends: + * [Cassandra 3.4+](./deployment/#cassandra) + * [Elasticsearch 7.x, 8.x](./deployment/#elasticsearch) + * [Badger](./deployment/#badger---local-storage) + * [Kafka](./deployment/#kafka) - as an intermediate buffer + * memory storage + * Custom backends via [Remote Storage API](./deployment/#remote-storage) + +## Quick Start + +See [Getting Started](./getting-started). + +## Screenshots + +### Traces View +[![Traces View](/img/traces-ss.png)](/img/traces-ss.png) + +### Trace Detail View +[![Detail View](/img/trace-detail-ss.png)](/img/trace-detail-ss.png) + +### Service Performance Monitoring View +![Service Performance Monitoring](/img/frontend-ui/spm.png) + +## Related links +- [Take Jaeger for a HotROD ride](https://medium.com/jaegertracing/take-jaeger-for-a-hotrod-ride-233cf43e46c2) (blog) +- [Evolving Distributed tracing At Uber Engineering](https://eng.uber.com/distributed-tracing/) (blog) +- [Mastering Distributed Tracing](https://shkuro.com/books/2019-mastering-distributed-tracing/) (book) +- [OpenTracing Tutorial (Java, Go, Python, Node.js, C#)](https://github.com/yurishkuro/opentracing-tutorial/) (tutorials) +- [Learning Distributed Tracing 101](https://tracing.cloudnative101.dev/docs/index.html) (tutorials) +- [Tracing HTTP request latency in Go with OpenTracing](https://medium.com/opentracing/tracing-http-request-latency-in-go-with-opentracing-7cc1282a100a) (blog) +- [Distributed Tracing with Jaeger & Prometheus on Kubernetes](https://blog.openshift.com/openshift-commons-briefing-82-distributed-tracing-with-jaeger-prometheus-on-kubernetes/) (blog) +- [Using Jaeger with Istio](https://istio.io/latest/docs/tasks/observability/distributed-tracing/jaeger/) (docs) +- [Using Jaeger with Envoy](https://www.envoyproxy.io/docs/envoy/latest/start/sandboxes/jaeger_tracing.html) (docs) + +[ubeross]: http://uber.github.io diff --git a/content/docs/1.61/apis.md b/content/docs/1.61/apis.md new file mode 100644 index 00000000..9ea63d19 --- /dev/null +++ b/content/docs/1.61/apis.md @@ -0,0 +1,144 @@ +--- +title: APIs +hasparent: true +--- + +Jaeger components implement various APIs for saving or retrieving trace data. + +The following labels are used to describe API compatibility guarantees. + +* **stable** - the API guarantees backwards compatibility. If breaking changes are going to be made in the future, they will result in a new API version, e.g. `/api/v2` URL prefix or a different namespace in the IDL. +* **internal** - the APIs are intended for internal communications between Jaeger components and are not recommended for use by external components. +* **deprecated** - the APIs that are only maintained for legacy reasons and will be phased out in the future. + +Since Jaeger v1.32, **jaeger-collector** and **jaeger-query** Service ports that serve gRPC endpoints enable [gRPC reflection][grpc-reflection]. Unfortunately, the internally used `gogo/protobuf` has a [compatibility issue][gogo-reflection] with the official `golang/protobuf`, and as a result only the `list` reflection command is currently working properly. + +## Span reporting APIs + +**jaeger-agent** and **jaeger-collector** are the two components of the Jaeger backend that can receive spans. At this time they support two sets of non-overlapping APIs. + +### OpenTelemetry Protocol (stable) + +Since v1.35, the Jaeger backend can receive trace data from the OpenTelemetry SDKs in their native [OpenTelemetry Protocol (OTLP)][otlp]. It is no longer necessary to configure the OpenTelemetry SDKs with Jaeger exporters, nor deploy the OpenTelemetry Collector between the OpenTelemetry SDKs and the Jaeger backend. + +The OTLP data is accepted in these formats: (1) binary gRPC, (2) Protobuf over HTTP, (3) JSON over HTTP. For more details on the OTLP receiver see the [official documentation][otlp-rcvr]. Note that not all configuration options are supported in **jaeger-collector** (see `--collector.otlp.*` [CLI Flags](../cli/#jaeger-collector)), and only tracing data is accepted, since Jaeger does not store other telemetry types. + +| Port | Protocol | Endpoint | Format +| ----- | ------- | ------------ | ---- +| 4317 | gRPC | n/a | Protobuf +| 4318 | HTTP | `/v1/traces` | Protobuf or JSON + +[otlp-rcvr]: https://github.com/open-telemetry/opentelemetry-collector/blob/main/receiver/otlpreceiver/README.md +[otlp]: https://github.com/open-telemetry/opentelemetry-proto/blob/main/docs/specification.md + +### Thrift over UDP (stable) + +**jaeger-agent** can only receive spans over UDP in Thrift format. The primary API is a UDP packet that contains a Thrift-encoded `Batch` struct defined in the [jaeger.thrift] IDL file, located in the [jaeger-idl] repository. Most Jaeger Clients use Thrift's `compact` encoding, however some client libraries do not support it (notably, Node.js) and use Thrift's `binary` encoding (sent to a different UDP port). **jaeger-agent**'s API is defined by the [agent.thrift] IDL file. + +For legacy reasons, **jaeger-agent** also accepts spans over UDP in Zipkin format, however, only very old versions of Jaeger clients can send data in that format and it is officially deprecated. + +### Protobuf via gRPC (stable) + +In a typical Jaeger deployment, **jaeger-agent**s receive spans from Clients and forward them to **jaeger-collector**s. Since Jaeger v1.11, the official and recommended protocol between **jaeger-agent**s and **jaeger-collector**s is `jaeger.api_v2.CollectorService` gRPC endpoint defined in [collector.proto] IDL file. The same endpoint can be used to submit trace data from SDKs directly to **jaeger-collector**. + +### Thrift over HTTP (stable) + +In some cases it is not feasible to deploy **jaeger-agent** next to the application, for example, when the application code is running as a serverless function. In these scenarios the SDKs can be configured to submit spans directly to **jaeger-collector**s over HTTP/HTTPS. + +The same [jaeger.thrift] payload can be submitted in an HTTP POST request to the `/api/traces` endpoint, for example, `https://jaeger-collector:14268/api/traces`. The `Batch` struct needs to be encoded using Thrift's `binary` encoding, and the HTTP request should specify the content type header: + +``` +Content-Type: application/vnd.apache.thrift.binary +``` + +### JSON over HTTP (n/a) + +There is no official Jaeger JSON format that can be accepted by **jaeger-collector**. +Jaeger does accept the OpenTelemetry protocol via JSON (see [above](#opentelemetry-protocol-stable)). + +### Zipkin Formats (stable) + +**jaeger-collector** can also accept spans in several Zipkin data formats, namely JSON v1/v2 and Thrift. **jaeger-collector** needs to be configured to enable Zipkin HTTP server, e.g. on port 9411 used by Zipkin collectors. The server enables two endpoints that expect POST requests: + +* `/api/v1/spans` for submitting spans in Zipkin JSON v1 or Zipkin Thrift format. +* `/api/v2/spans` for submitting spans in Zipkin JSON v2. + +## Trace retrieval APIs + +Traces saved in the storage can be retrieved by calling **jaeger-query** Service. + +### gRPC/Protobuf (stable) + +The recommended way for programmatically retrieving traces and other data is via the `jaeger.api_v2.QueryService` gRPC endpoint defined in [query.proto] IDL file. In the default configuration this endpoint is accessible from `jaeger-query:16685`. + +### HTTP JSON (internal) + +Jaeger UI communicates with **jaeger-query** Service via JSON API. For example, a trace can be retrieved via a GET request to `https://jaeger-query:16686/api/traces/{trace-id-hex-string}`. This JSON API is intentionally undocumented and subject to change. + +## Remote Storage API (stable) + +When using the `grpc` storage type (a.k.a. [remote storage](../deployment/#remote-storage)), Jaeger components can use custom storage backends as long as those backends implement the gRPC [Remote Storage API][storage.proto]. + +## Remote Sampling Configuration (stable) + +This API supports Jaeger's [Remote Sampling](../sampling/#remote-sampling) protocol, defined in the [sampling.proto] IDL file. + +Both **jaeger-agent** and **jaeger-collector** implement the API. See [Remote Sampling](../sampling/#remote-sampling) for details on how to configure the Collector with sampling strategies. **jaeger-agent** is merely acting as a proxy to **jaeger-collector**. + +The following table lists different endpoints and formats that can be used to query for sampling strategies. The official HTTP/JSON endpoints use standard [Protobuf-to-JSON mapping](https://developers.google.com/protocol-buffers/docs/proto3#json). + +Component | Port | Endpoint | Format | Notes +--------- | ----- | ----------------- | --------- | ----- +Collector | 14268 | `/api/sampling` | HTTP/JSON | Recommended for most SDKs +Collector | 14250 | [sampling.proto] | gRPC | For SDKs that want to use gRPC (e.g. OpenTelemetry Java SDK) +Agent | 5778 | `/sampling` | HTTP/JSON | Recommended for most SDKs if the Agent is used in a deployment +Agent | 5778 | `/` (deprecated) | HTTP/JSON | Legacy format, with enums encoded as numbers. **Not recommended.** + +**Examples** + +Run all-in-one in one terminal: +```shell +$ go run ./cmd/all-in-one \ + --sampling.strategies-file=cmd/all-in-one/sampling_strategies.json +``` + +Query different endpoints in another terminal: +```shell +# Collector +$ curl "http://localhost:14268/api/sampling?service=foo" +{"strategyType":"PROBABILISTIC","probabilisticSampling":{"samplingRate":1}} + +# Agent +$ curl "http://localhost:5778/sampling?service=foo" +{"strategyType":"PROBABILISTIC","probabilisticSampling":{"samplingRate":1}} + +# Agent, legacy endpoint / (not recommended) +$ curl "http://localhost:5778/?service=foo" +{"strategyType":0,"probabilisticSampling":{"samplingRate":1}} +``` + +## Service dependencies graph (internal) + +Can be retrieved from**jaeger-query** Service at `/api/dependencies` endpoint. The GET request expects two parameters: + +* `endTs` (number of milliseconds since epoch) - the end of the time interval +* `lookback` (in milliseconds) - the length the time interval (i.e. start-time + lookback = end-time). + +The returned JSON is a list of edges represented as tuples `(caller, callee, count)`. + +For programmatic access to the service graph, the recommended API is gRPC/Protobuf described above. + +## Service Performance Monitoring (internal) + +Please refer to the [SPM Documentation](../spm#api) + +[jaeger-idl]: https://github.com/jaegertracing/jaeger-idl/ +[jaeger.thrift]: https://github.com/jaegertracing/jaeger-idl/blob/main/thrift/jaeger.thrift +[agent.thrift]: https://github.com/jaegertracing/jaeger-idl/blob/main/thrift/agent.thrift +[sampling.thrift]: https://github.com/jaegertracing/jaeger-idl/blob/main/thrift/sampling.thrift +[collector.proto]: https://github.com/jaegertracing/jaeger-idl/blob/main/proto/api_v2/collector.proto +[query.proto]: https://github.com/jaegertracing/jaeger-idl/blob/main/proto/api_v2/query.proto +[sampling.proto]: https://github.com/jaegertracing/jaeger-idl/blob/main/proto/api_v2/sampling.proto +[grpc-reflection]: https://github.com/grpc/grpc-go/blob/master/Documentation/server-reflection-tutorial.md#enable-server-reflection +[gogo-reflection]: https://jbrandhorst.com/post/gogoproto/#reflection +[storage.proto]: https://github.com/jaegertracing/jaeger/blob/main/plugin/storage/grpc/proto/storage.proto diff --git a/content/docs/1.61/architecture.md b/content/docs/1.61/architecture.md new file mode 100644 index 00000000..e0b11458 --- /dev/null +++ b/content/docs/1.61/architecture.md @@ -0,0 +1,125 @@ +--- +title: Architecture +weight: 3 +children: +- title: APIs + url: apis +- title: Sampling + url: sampling +--- + +## Terminology + +Jaeger represents tracing data in a data model inspired by the [OpenTracing Specification](https://github.com/opentracing/specification/blob/master/specification.md). The data model is logically very similar to [OpenTelemetry Traces](https://opentelemetry.io/docs/concepts/signals/traces/), with some naming differences: + +| Jaeger | OpenTelemetry | Notes | +| -------------------- | --------------- | ----------------------------------------------------------------------- | +| Tags | Attributes | Both support typed values, but nested tags are not supported in Jaeger. | +| Span Logs | Span Events | Point-in-time events on the span recorded in a structured form. | +| Span References | Span Links | Jaeger's Span References have a required type (`child-of` or `follows-from`) and always refer to predecessor spans; OpenTelemetry's Span Links have no type, but allow attributes. | +| Process | Resource | A struct describing the entity that produces the telemetry. | + +### Span + +A **span** represents a logical unit of work that has an operation name, the start time of the operation, and the duration. Spans may be nested and ordered to model causal relationships. + +![Traces And Spans](/img/spans-traces.png) + +### Trace + +A **trace** represents the data or execution path through the system. It can be thought of as a directed acyclic graph of spans. + +### Baggage + +**Baggage** is arbitrary user-defined metadata (key-value pairs) that can be attached to distributed context and propagated by the tracing SDKs. See [W3C Baggage](https://www.w3.org/TR/baggage/) for more information. + +## Architecture + +Jaeger can be deployed either as an **all-in-one** binary, where all Jaeger backend components +run in a single process, or as a scalable distributed system. There are two main deployment options discussed below. + +### Direct to storage + +In this deployment the collectors receive the data from traced applications and write it directly to storage. The storage must be able to handle both average and peak traffic. Collectors 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. + +Collectors are able to centrally serve sampling configuration to the SDKs, known as [remote sampling mode](../sampling/#remote-sampling). They can also enable automatic sampling configuration calculation, known as [adaptive sampling](../sampling/#adaptive-sampling). + +![Architecture](/img/architecture-v1-2023.png) + +### Via Kafka + +To prevent data loss between collectors and storage, Kafka can be used as an intermediary, persistent queue. An additional component, **jaeger-ingester**, needs to be deployed to read data from Kafka and save to the database. Multiple **jaeger-ingester**s can be deployed to scale up ingestion; they will automatically partition the load across them. + +![Architecture](/img/architecture-v2-2023.png) + +### With OpenTelemetry Collector + +You **do not need to use OpenTelemetry Collector**, because **jaeger-collector** can receive OpenTelemetry data directly from the OpenTelemetry SDKs (using OTLP exporters). However, if you already use the OpenTelemetry Collectors, such as for gathering other types of telemetry or for pre-processing / enriching the tracing data, it __can be placed between__ the SDKs and **jaeger-collector**'s. The OpenTelemetry Collectors can be run as an application sidecar, as a host agent / daemon, or as a central cluster. + +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). + +![Architecture](/img/architecture-otel.png) + +#### OpenTelemetry Collector as a sidecar / host agent + +Benefits: + +* 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. +* Collector may provide data enrichment by adding environment information, like k8s pod name. +* Resource usage for data enrichment can be distributed across all application hosts. + +Downsides: + +* An extra layer of marshaling/unmarshaling the data. + +#### OpenTelemetry Collector as a remote cluster + +Benefits: +* Sharding capabilities, e.g., when using [tail-based sampling](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/tailsamplingprocessor/README.md). + +Downsides: + +* An extra layer of marshaling/unmarshaling the data. + +## Components + +This section details the constituent parts of Jaeger and how they relate to each other. It is arranged by the order in which spans from your application interact with them. + +### Tracing SDKs + +{{< warning >}} +The Jaeger project historically provided a collection of tracing SDKs, called [Jaeger clients](../client-libraries). These libraries have been retired in favor of the [OpenTelemetry SDKs](https://opentelemetry.io). +{{< /warning >}} + +In order to generate tracing data, the applications must be instrumented. An instrumented application creates spans when receiving new requests and attaches context information (trace id, span id, and baggage) to outgoing requests. Only the ids and baggage are propagated with requests; all other profiling data, like operation name, timing, tags and logs, is not propagated. Instead, it is exported out of process to the Jaeger backend asynchronously, in the background. + +![Context propagation explained](/img/context-prop-2023.png) + +There are many ways to instrument an application: + * manually, using the tracing APIs directly, + * relying on instrumentation already created for a variety of existing open source frameworks, + * automatically, via byte code manipulation, monkey-patching, eBPF, and similar techniques. + +Instrumentation typically should not depend on specific tracing SDKs, but only on abstract tracing APIs like the OpenTelemetry API. The tracing SDKs implement the tracing APIs and take care of data export. + +The instrumentation is designed to be always on in production. To minimize overhead, the SDKs employ various sampling strategies. When a trace is sampled, the profiling span data is captured and transmitted to the Jaeger backend. When a trace is not sampled, no profiling data is collected at all, and the calls to the tracing API are short-circuited to incur a minimal amount of overhead. For more information, please refer to the [Sampling](../sampling/) page. + +### Agent + +{{< warning >}} +**jaeger-agent** is [deprecated](https://github.com/jaegertracing/jaeger/issues/4739). The OpenTelemetry data can be sent from the OpenTelemetry SDKs (equipped with OTLP exporters) directly to **jaeger-collector**. Alternatively, use the OpenTelemetry Collector as a local agent. +{{< /warning >}} + +**jaeger-agent** is a network daemon that listens for spans sent over UDP, which are batched and sent to the collector. It is designed to be deployed to all hosts as an infrastructure component. The agent abstracts the routing and discovery of the collectors away from the client. **jaeger-agent** is **not** a required component. + +### Collector + +**jaeger-collector** receives traces, runs them through a processing pipeline for validation and clean-up/enrichment, and stores them in a storage backend. Jaeger comes with built-in support for several storage backends (see [Deployment](../deployment)), as well as extensible plugin framework for implementing custom storage plugins. + +### Query + +**jaeger-query** is a service that exposes the [APIs](../apis) for retrieving traces from storage and hosts a Web UI for searching and analyzing traces. + +### Ingester + +**jaeger-ingester** is a service that reads traces from Kafka and writes them to a storage backend. Effectively, it is a stripped-down version of the Jaeger collector that supports Kafka as the only input protocol. diff --git a/content/docs/1.61/cli.md b/content/docs/1.61/cli.md new file mode 100644 index 00000000..77e751ab --- /dev/null +++ b/content/docs/1.61/cli.md @@ -0,0 +1,13 @@ +--- +title: CLI flags +widescreen: true +hasparent: true +--- + +This is auto-generated documentation for CLI flags supported by Jaeger binaries. + + * CLI flags for some binaries change depending on the `SPAN_STORAGE_TYPE` environment variable. Relevant variations are included below. + * Some binaries support _commands_ (mostly informational), such as `env`, `docs`, `version`, and `status`. These commands are not included here. + * All parameters can be provided via environment variables, by changing all letters to upper-case and replacing all punctuation characters with the underscore `_`. For example, the value for the flag `--cassandra.connections-per-host` can be provided via the `CASSANDRA_CONNECTIONS_PER_HOST` environment variable. + +{{< cli/tools-list >}} diff --git a/content/docs/1.61/deployment.md b/content/docs/1.61/deployment.md new file mode 100644 index 00000000..ab911b0e --- /dev/null +++ b/content/docs/1.61/deployment.md @@ -0,0 +1,718 @@ +--- +title: Deployment +weight: 4 +children: +- title: Operator for Kubernetes + navtitle: Kubernetes + url: operator +- title: Frontend/UI + url: frontend-ui +- title: CLI Flags + url: cli +- title: Security + url: security +- title: On Windows + url: windows +- title: Service Performance Monitoring (SPM) + navtitle: SPM + url: spm +--- + +The main Jaeger backend components are released as Docker images on [Docker Hub](https://hub.docker.com/r/jaegertracing) and [Quay](https://quay.io/organization/jaegertracing): + +Component | Docker Hub | Quay +--------------------- | -------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------- +**jaeger-all-in-one** | [hub.docker.com/r/jaegertracing/all-in-one/](https://hub.docker.com/r/jaegertracing/all-in-one/) | [quay.io/repository/jaegertracing/all-in-one](https://quay.io/repository/jaegertracing/all-in-one) +**jaeger-agent** | [hub.docker.com/r/jaegertracing/jaeger-agent/](https://hub.docker.com/r/jaegertracing/jaeger-agent/) | [quay.io/repository/jaegertracing/jaeger-agent](https://quay.io/repository/jaegertracing/jaeger-agent) +**jaeger-collector** | [hub.docker.com/r/jaegertracing/jaeger-collector/](https://hub.docker.com/r/jaegertracing/jaeger-collector/) | [quay.io/repository/jaegertracing/jaeger-collector](https://quay.io/repository/jaegertracing/jaeger-collector) +**jaeger-query** | [hub.docker.com/r/jaegertracing/jaeger-query/](https://hub.docker.com/r/jaegertracing/jaeger-query/) | [quay.io/repository/jaegertracing/jaeger-query](https://quay.io/repository/jaegertracing/jaeger-query) +**jaeger-ingester** | [hub.docker.com/r/jaegertracing/jaeger-ingester/](https://hub.docker.com/r/jaegertracing/jaeger-ingester/) | [quay.io/repository/jaegertracing/jaeger-ingester](https://quay.io/repository/jaegertracing/jaeger-ingester) +**jaeger-remote-storage** | [hub.docker.com/r/jaegertracing/jaeger-remote-storage/](https://hub.docker.com/r/jaegertracing/jaeger-remote-storage/) | [quay.io/repository/jaegertracing/jaeger-remote-storage](https://quay.io/repository/jaegertracing/jaeger-remote-storage) + +The images listed above are the primary release versions. Most components have additional images published: + * `${component}-debug` images include Delve debugger + * `${component}-snapshot` images are published from the tip of the main branch for every commit, allowing testing of unreleased versions + * `${component}-debug-snapshot` snapshot images that include the Delve debugger + +There are orchestration templates for running Jaeger with: + + * Kubernetes: [github.com/jaegertracing/jaeger-kubernetes](https://github.com/jaegertracing/jaeger-kubernetes), + * OpenShift: [github.com/jaegertracing/jaeger-openshift](https://github.com/jaegertracing/jaeger-openshift). + +## Configuration Options + +Jaeger binaries can be configured in a number of ways (in the order of decreasing priority): + + * command line arguments, + * environment variables, + * configuration files in JSON, TOML, YAML, HCL, or Java properties formats. + +To see the complete list of options, run the binary with the `help` command or refer to the [CLI Flags](../cli/) page for more information. Options that are specific to a certain storage backend are _only listed if the storage type is selected_. For example, to see all available options in the Collector with Cassandra storage: + +```sh +$ docker run --rm \ + -e SPAN_STORAGE_TYPE=cassandra \ + jaegertracing/jaeger-collector:{{< currentVersion >}} \ + help +``` + +In order to provide configuration parameters via environment variables, find the respective command line option and convert its name to UPPER_SNAKE_CASE, for example: + +Command line option | Environment variable +-----------------------------------|------------------------------- +`--cassandra.connections-per-host` | `CASSANDRA_CONNECTIONS_PER_HOST` +`--metrics-backend` | `METRICS_BACKEND` + +## All-in-one + +Jaeger all-in-one is a special distribution that combines three Jaeger components, [agent](#agent), [collector](#collector), and [query service/UI](#query-service--ui), in a single binary or container image. It is useful for single-node deployments where your trace volume is light enough to be handled by a single instance. By default, all-in-one starts with `memory` storage, meaning it will lose all data upon restart. All other [span storage backends](#span-storage-backends) can also be used with all-in-one, but `memory` and `badger` are exclusive to all-in-one because they cannot be shared between instances. + +All-in-one listens to the same ports as the components it contains (described below), with the exception of the admin port. + +Port | Protocol | Function +----- | ------- | --- +14269 | HTTP | admin port: health check at `/` and metrics at `/metrics` + +```bash +## make sure to expose only the ports you use in your deployment scenario! +docker run -d --name jaeger \ + -e COLLECTOR_OTLP_ENABLED=true \ + -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 \ + -p 5775:5775/udp \ + -p 6831:6831/udp \ + -p 6832:6832/udp \ + -p 5778:5778 \ + -p 16686:16686 \ + -p 14250:14250 \ + -p 14268:14268 \ + -p 14269:14269 \ + -p 4317:4317 \ + -p 4318:4318 \ + -p 9411:9411 \ + jaegertracing/all-in-one:{{< currentVersion >}} +``` + +You can navigate to `http://localhost:16686` to access the Jaeger UI. + +## Agent + +{{< warning >}} +**jaeger-agent** is [deprecated](https://github.com/jaegertracing/jaeger/issues/4739). The OpenTelemetry data can be sent from the OpenTelemetry SDKs (equipped with OTLP exporters) directly to **jaeger-collector**. See the [Architecture](../architecture) page for alternative deployment options. +{{< /warning >}} + +**jaeger-agent** is designed to receive tracing data in Thrift format over UDP and run locally on each host, either as a host agent / daemon or as an application sidecar. **jaeger-agent** exposes the following ports: + +Port | Protocol | Function +----- | ------- | --- +6831 | UDP | Accepts [jaeger.thrift][jaeger-thrift] in `compact` Thrift protocol used by most current Jaeger clients. +6832 | UDP | Accepts [jaeger.thrift][jaeger-thrift] in `binary` Thrift protocol used by Node.js Jaeger client (because [thriftrw][thriftrw] npm package does not support `compact` protocol). +5778 | HTTP | Serves SDK configs, namely sampling strategies at `/sampling` (see [Remote Sampling](../sampling/#remote-sampling)). +5775 | UDP | Accepts [zipkin.thrift][zipkin-thrift] in `compact` Thrift protocol (deprecated; only used by very old Jaeger clients, circa 2016). +14271 | HTTP | Admin port: health check at `/` and metrics at `/metrics`. + +It can be executed directly on the host or via Docker, as follows: + +```sh +## make sure to expose only the ports you use in your deployment scenario! +docker run \ + --rm \ + -p6831:6831/udp \ + -p6832:6832/udp \ + -p5778:5778/tcp \ + -p5775:5775/udp \ + jaegertracing/jaeger-agent:{{< currentVersion >}} +``` + +### Discovery System Integration + +**jaeger-agent**s can connect point-to-point to a single **jaeger-collector** address, which could be +load balanced by another infrastructure component (e.g. DNS) across multiple **jaeger-collector**s. +**jaeger-agent** can also be configured with a static list of **jaeger-collector** addresses. + +On Docker, a command like the following can be used: + +```sh +docker run \ + --rm \ + -p5775:5775/udp \ + -p6831:6831/udp \ + -p6832:6832/udp \ + -p5778:5778/tcp \ + jaegertracing/jaeger-agent:{{< currentVersion >}} \ + --reporter.grpc.host-port=jaeger-collector.jaeger-infra.svc:14250 +``` + +When using gRPC, you have several options for load balancing and name resolution: + +* Single connection and no load balancing. This is the default if you specify a single `host:port`. (example: `--reporter.grpc.host-port=jaeger-collector.jaeger-infra.svc:14250`) +* Static list of hostnames and round-robin load balancing. This is what you get with a comma-separated list of addresses. (example: `reporter.grpc.host-port=jaeger-collector1:14250,jaeger-collector2:14250,jaeger-collector3:14250`) +* Dynamic DNS resolution and round-robin load balancing. To get this behavior, prefix the address with `dns:///` and gRPC will attempt to resolve the hostname using SRV records (for [external load balancing](https://github.com/grpc/grpc/blob/master/doc/load-balancing.md)), TXT records (for [service configs](https://github.com/grpc/grpc/blob/master/doc/service_config.md)), and A records. Refer to the [gRPC Name Resolution docs](https://github.com/grpc/grpc/blob/master/doc/naming.md) and the [dns_resolver.go implementation](https://github.com/grpc/grpc-go/blob/master/resolver/dns/dns_resolver.go) for more info. (example: `--reporter.grpc.host-port=dns:///jaeger-collector.jaeger-infra.svc:14250`) + +### Agent level tags + +Jaeger supports agent level tags, that can be added to the process tags of all spans passing through **jaeger-agent**. This is supported through the command line flag `--agent.tags=key1=value1,key2=value2,...,keyn=valuen`. Tags can also be set through an environment flag like so - `--agent.tags=key=${envFlag:defaultValue}` - The tag value will be set to the value of the `envFlag` environment key and `defaultValue` if not set. + +## Collector + +**jaeger-collector**s are stateless and thus many instances of **jaeger-collector** can be run in parallel. +**jaeger-collector**s require almost no configuration, except for storage location, such as +`--cassandra.keyspace` and `--cassandra.servers` options, or the location of Elasticsearch cluster, +via `--es.server-urls`, depending on which storage is specified. See the [CLI Flags](../cli/) for all +command line options. + +At default settings **jaeger-collector** exposes the following ports: + +| Port | Protocol | Endpoint | Function +| ----- | ------- | -------- | ---- +| 4317 | gRPC | n/a | Accepts traces in [OpenTelemetry OTLP format][otlp] (Protobuf). +| 4318 | HTTP | `/v1/traces` | Accepts traces in [OpenTelemetry OTLP format][otlp] (Protobuf and JSON). +| 14268 | HTTP | `/api/sampling` | Serves sampling policies (see [Remote Sampling](../sampling/#remote-sampling)). +| | | `/api/traces` | Accepts spans in [jaeger.thrift][jaeger-thrift] format with `binary` thrift protocol (`POST`). +| 14269 | HTTP | `/` | Admin port: health check (`GET`). +| | | `/metrics` | Prometheus-style metrics (`GET`). +| 9411 | HTTP | `/api/v1/spans` and `/api/v2/spans` | Accepts Zipkin spans in Thrift, JSON and Proto (disabled by default). +| 14250 | gRPC | n/a | Used by **jaeger-agent** to send spans in [model.proto][] Protobuf format. + +## Ingester + +**jaeger-ingester** is a service which reads span data from Kafka topic and writes it to another storage backend (Elasticsearch or Cassandra). + +Port | Protocol | Function +----- | ------- | --- +14270 | HTTP | admin port: health check at `/` and metrics at `/metrics` + +To view all exposed configuration options run the following command: +```sh +docker run \ + -e SPAN_STORAGE_TYPE=cassandra \ + jaegertracing/jaeger-ingester:{{< currentVersion >}} + --help +``` + +## Query Service & UI + +**jaeger-query** serves the API endpoints and a React/Javascript UI. +The service is stateless and is typically run behind a load balancer, such as [**NGINX**](https://www.nginx.com/). + +At default settings the **jaeger-query** service exposes the following port(s): + +Port | Protocol | Function +----- | ------- | --- +16685 | gRPC | Protobuf/gRPC [QueryService](https://github.com/jaegertracing/jaeger-idl/blob/master/proto/api_v2/query.proto) +16686 | HTTP | `/api/*` endpoints and Jaeger UI at `/` +16687 | HTTP | admin port: health check at `/` and metrics at `/metrics` + +### Minimal deployment example (Elasticsearch backend): +```sh +docker run -d --rm \ + -p 16685:16685 \ + -p 16686:16686 \ + -p 16687:16687 \ + -e SPAN_STORAGE_TYPE=elasticsearch \ + -e ES_SERVER_URLS=http://: \ + jaegertracing/jaeger-query:{{< currentVersion >}} +``` + +### Clock Skew Adjustment + +Jaeger backend combines trace data from applications that are usually running on different hosts. The hardware clocks on the hosts often experience relative drift, known as the [clock skew effect](https://en.wikipedia.org/wiki/Clock_skew). Clock skew can make it difficult to reason about traces, for example, when a server span may appear to start earlier than the client span, which should not be possible. **jaeger-query** service implements a clock skew adjustment algorithm ([code](https://github.com/jaegertracing/jaeger/blob/master/model/adjuster/clockskew.go)) to correct for clock drift, using the knowledge about causal relationships between spans. All adjusted spans have a warning displayed in the UI that provides the exact clock skew delta applied to their timestamps. + +Sometimes these adjustments themselves make the trace hard to understand. For example, when repositioning the server span within the bounds of its parent span, Jaeger does not know the exact relationship between the request and response latencies, so it assumes they are equal and places the child span in the middle of the parent span (see [issue #961](https://github.com/jaegertracing/jaeger/issues/961#issuecomment-453925244)). + +**jaeger-query** service supports a configuration flag `--query.max-clock-skew-adjustment` that controls how much clock skew adjustment should be allowed. Setting this parameter to zero (`0s`) disables clock skew adjustment completely. This setting applies to all traces retrieved from the given query service. There is an open [ticket #197](https://github.com/jaegertracing/jaeger-ui/issues/197) to support toggling the adjustment on and off directly in the UI. + +### UI Base Path + +The base path for all **jaeger-query** HTTP routes can be set to a non-root value, e.g. `/jaeger` would cause all UI URLs to start with `/jaeger`. This can be useful when running **jaeger-query** behind a reverse proxy. + +The base path can be configured via the `--query.base-path` command line parameter or the `QUERY_BASE_PATH` environment variable. + +### UI Customization and Embedding + +Please refer to the [dedicated Frontend/UI page](../frontend-ui/). + +## Remote Storage (component) + +**jaeger-remote-storage** implements the [Remote Storage gRPC API][storage.proto] and proxies it into one of the regular Jaeger backends. It can be useful in the situation when we want to run a full deployment of Jaeger components, e.g., separate collector and query services, but use a single-node storage backend like the memory store or Badger. Without the remote storage, the single-node backends can only be used with all-in-one since they cannot be shared between multiple processes. + +At default settings the service listens on the following port(s): + +Port | Protocol | Function +----- | ------- | --- +17271 | gRPC | [Remote Storage API][storage.proto] +17270 | HTTP | admin port: health check at `/` and metrics at `/metrics` + +## Span Storage Backends + +Jaeger requires a persistent storage backend. Cassandra and Elasticsearch/OpenSearch are the primary supported distributed storage backends. Additional backends are [discussed here](https://github.com/jaegertracing/jaeger/issues/638). + +The storage type can be passed via `SPAN_STORAGE_TYPE` environment variable. Valid values are `cassandra`, `elasticsearch`, `kafka` (only as a buffer), `badger` and `memory`. + +As of version 1.6.0, it's possible to use multiple storage types at the same time by providing a comma-separated list of valid types to the `SPAN_STORAGE_TYPE` environment variable. It's important to note that all listed storage types are used for writing, but only the first type in the list will be used for reading and archiving. + +For large scale production deployment the Jaeger team [recommends OpenSearch backend over Cassandra](../faq/#what-is-the-recommended-storage-backend). + +### Memory + +The in-memory storage is not intended for production workloads. It's intended as a simple solution to get started quickly and +data will be lost once the process exits. + +By default, there's no limit in the amount of traces stored in memory but a limit can be established by passing an +integer value via `--memory.max-traces`. + +### Badger - local storage + +* Since Jaeger v1.9 + +[Badger](https://github.com/dgraph-io/badger) is an embedded local storage, only available +with **all-in-one** distribution. By default, it acts as ephemeral storage using a temporary file system. +This can be overridden by using the `--badger.ephemeral=false` option. + +```sh +docker run \ + -e SPAN_STORAGE_TYPE=badger \ + -e BADGER_EPHEMERAL=false \ + -e BADGER_DIRECTORY_VALUE=/badger/data \ + -e BADGER_DIRECTORY_KEY=/badger/key \ + -v :/badger \ + -p 16686:16686 \ + jaegertracing/all-in-one:{{< currentVersion >}} +``` + +* [Upgrade Badger v1 to v3](https://github.com/jaegertracing/jaeger/blob/main/plugin/storage/badger/docs/upgrade-v1-to-v3.md) +* [Badger file permissions as non-root service](https://github.com/jaegertracing/jaeger/blob/main/plugin/storage/badger/docs/storage-file-non-root-permission.md) + +### Cassandra +* Supported versions: 3.4+ + +Deploying Cassandra itself is out of scope for our documentation. One good +source of documentation is the [Apache Cassandra Docs](https://cassandra.apache.org/doc/latest/). + +#### Configuration +##### Minimal +```sh +docker run \ + -e SPAN_STORAGE_TYPE=cassandra \ + -e CASSANDRA_SERVERS=<...> \ + jaegertracing/jaeger-collector:{{< currentVersion >}} +``` + +Note: White space characters are allowed in `CASSANDRA_SERVERS`. For Example: Servers can be passed as `CASSANDRA_SERVERS="1.2.3.4, 5.6.7.8" for better readability. + +##### All options +To view the full list of configuration options, you can run the following command: +```sh +docker run \ + -e SPAN_STORAGE_TYPE=cassandra \ + jaegertracing/jaeger-collector:{{< currentVersion >}} \ + --help +``` + +#### Schema script + +A script is provided to initialize Cassandra keyspace and schema +using Cassandra's interactive shell [`cqlsh`][cqlsh]: + +```sh +MODE=test sh ./plugin/storage/cassandra/schema/create.sh | cqlsh +``` + +Or using the published Docker image (make sure to provide the right IP address): +```sh +docker run \ + -e CQLSH_HOST={server IP address} \ + jaegertracing/jaeger-cassandra-schema:{{< currentVersion >}} +``` + +For production deployment, pass `MODE=prod DATACENTER={datacenter}` arguments to the script, +where `{datacenter}` is the name used in the Cassandra configuration / network topology. + +The script also allows overriding TTL, keyspace name, replication factor, etc. +Run the script without arguments to see the full list of recognized parameters. + +**Note**: See [README](https://github.com/jaegertracing/jaeger/blob/main/plugin/storage/cassandra/schema/README.md) for more details on Cassandra schema management. + +#### TLS support + +Jaeger supports TLS client to node connections as long as you've configured +your Cassandra cluster correctly. After verifying with e.g. `cqlsh`, you can +configure the collector and query like this: + +```sh +docker run \ + -e CASSANDRA_SERVERS=<...> \ + -e CASSANDRA_TLS=true \ + -e CASSANDRA_TLS_SERVER_NAME="CN-in-certificate" \ + -e CASSANDRA_TLS_KEY= \ + -e CASSANDRA_TLS_CERT= \ + -e CASSANDRA_TLS_CA= \ + jaegertracing/jaeger-collector:{{< currentVersion >}} +``` + +The schema tool also supports TLS. You need to make a custom cqlshrc file like +so: + +``` +# Creating schema in a cassandra cluster requiring client TLS certificates. +# +# Create a volume for the schema docker container containing four files: +# cqlshrc: this file +# ca-cert: the cert authority for your keys +# client-key: the keyfile for your client +# client-cert: the cert file matching client-key +# +# if there is any sort of DNS mismatch and you want to ignore server validation +# issues, then uncomment validate = false below. +# +# When running the container, map this volume to /root/.cassandra and set the +# environment variable CQLSH_SSL=--ssl +[ssl] +certfile = ~/.cassandra/ca-cert +userkey = ~/.cassandra/client-key +usercert = ~/.cassandra/client-cert +# validate = false +``` + +#### Compatible Backends + +* ScyllaDB [can be used](https://github.com/jaegertracing/jaeger/blob/main/plugin/storage/scylladb/README.md) as a drop-in replacement for Cassandra since it uses the same data model and query language. + +### Elasticsearch +* Supported since Jaeger v0.6.0 +* Supported ES versions: 7.x, 8.x (since Jaeger v1.52.0) + +Elasticsearch version is automatically retrieved from root/ping endpoint. +Based on this version Jaeger uses compatible index mappings and Elasticsearch REST API. +The version can be explicitly provided via `--es.version=` flag. + +Elasticsearch does not require initialization other than +[installing and running Elasticsearch](https://www.elastic.co/downloads/elasticsearch). +Once it is running, pass the correct configuration values to **jaeger-collector** and **jaeger-query**. + +#### Configuration +##### Minimal +```sh +docker run \ + -e SPAN_STORAGE_TYPE=elasticsearch \ + -e ES_SERVER_URLS=<...> \ + jaegertracing/jaeger-collector:{{< currentVersion >}} +``` + +##### All options +To view the full list of configuration options, you can run the following command: +```sh +docker run \ + -e SPAN_STORAGE_TYPE=elasticsearch \ + jaegertracing/jaeger-collector:{{< currentVersion >}} \ + --help +``` + +#### Shards and Replicas for Elasticsearch indices + +Shards and replicas are some configuration values to take special attention to, because this is decided upon +index creation. [This article](https://www.elastic.co/blog/how-many-shards-should-i-have-in-my-elasticsearch-cluster) goes into +more information about choosing how many shards should be chosen for optimization. + +#### Elasticsearch Rollover + +[Elasticsearch rollover](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-rollover-index.html) is an index management strategy that optimizes use of resources allocated to indices. +For example, indices that do not contain any data still allocate shards, and conversely, a single index might contain significantly more data than the others. +Jaeger by default stores data in daily indices which might not optimally utilize resources. Rollover feature can be enabled by `--es.use-aliases=true`. + +Rollover lets you configure when to roll over to a new index based on one or more of the following criteria: + +* `max_age` - the maximum age of the index. It uses [time units](https://www.elastic.co/guide/en/elasticsearch/reference/master/common-options.html#time-units): `d`, `h`, `m`. +* `max_docs` - the maximum documents in the index. +* `max_size` - the maximum estimated size of primary shards (since Elasticsearch 6.x). It uses [byte size units](https://www.elastic.co/guide/en/elasticsearch/reference/master/common-options.html#byte-units) `tb`, `gb`, `mb`. + +Rollover index management strategy is more complex than using the default daily indices and it requires an initialization job to prepare the storage and two cron jobs to manage indices. + +To learn more about rollover index management in Jaeger refer to this +[article](https://medium.com/jaegertracing/using-elasticsearch-rollover-to-manage-indices-8b3d0c77915d). + +For automated rollover, please refer to [Elasticsearch ILM support](#elasticsearch-ilm-support). +##### Initialize + +The following command prepares Elasticsearch for rollover deployment by creating index aliases, indices, and index templates: + +```sh +docker run -it --rm --net=host jaegertracing/jaeger-es-rollover:latest init http://localhost:9200 # <1> +``` + +If you need to initialize archive storage, add `-e ARCHIVE=true`. + +After the initialization Jaeger can be deployed with `--es.use-aliases=true`. + +##### Rolling over to a new index + +The next step is to periodically execute the rollover API which rolls the write alias to a new index based on supplied conditions. The command also adds a new index to the read alias to make new data available for search. + +```shell +docker run -it --rm --net=host -e CONDITIONS='{"max_age": "2d"}' jaegertracing/jaeger-es-rollover:latest rollover http://localhost:9200 # <1> +``` + +<1> The command rolls the alias over to a new index if the age of the current write index is older than 2 days. For more conditions see [Elasticsearch docs](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-rollover-index.html). + +The next step is to remove old indices from read aliases. It means that old data will not be available for search. This imitates the behavior of `--es.max-span-age` flag used in the default index-per-day deployment. This step could be optional and old indices could be simply removed by index cleaner in the next step. + +```sh +docker run -it --rm --net=host -e UNIT=days -e UNIT_COUNT=7 jaegertracing/jaeger-es-rollover:latest lookback http://localhost:9200 # <1> +``` + +<1> Removes indices older than 7 days from read alias. + +##### Remove old data + +The historical data can be removed with the `jaeger-es-index-cleaner` that is also used for daily indices. + +```shell +docker run -it --rm --net=host -e ROLLOVER=true jaegertracing/jaeger-es-index-cleaner:latest 14 http://localhost:9200 # <1> +``` + +<1> Remove indices older than 14 days. + + +#### Elasticsearch ILM support +{{< warning >}} +Experimental feature added in [release v1.22.0](https://github.com/jaegertracing/jaeger/releases/tag/v1.22.0). + +Supported Elasticsearch versions: 7.x +{{< /warning >}} +[Elasticsearch ILM](https://www.elastic.co/guide/en/elasticsearch/reference/current/index-lifecycle-management.html) automatically manages indices according to performance, resiliency, and retention requirements. + +For example: +* Rollover to a new index by size (bytes or number of documents) or age, archiving previous indices +* Delete stale indices to enforce data retention standards + +###### Enabling ILM support +* Create an ILM policy in elasticsearch named jaeger-ilm-policy. + + For example, the following policy will rollover the "active" index when it is + older than 1m and delete indices that are older than 2m. + + ```shell + curl -X PUT http://localhost:9200/_ilm/policy/jaeger-ilm-policy \ + -H 'Content-Type: application/json; charset=utf-8' \ + --data-binary @- << EOF + { + "policy": { + "phases": { + "hot": { + "min_age": "0ms", + "actions": { + "rollover": { + "max_age": "1m" + }, + "set_priority": { + "priority": 100 + } + } + }, + "delete": { + "min_age": "2m", + "actions": { + "delete": {} + } + } + } + } + } + EOF + ``` +* Run elasticsearch initializer with `ES_USE_ILM=true`: + + ```shell + docker run -it --rm --net=host -e ES_USE_ILM=true jaegertracing/jaeger-es-rollover:latest init http://localhost:9200 # <1> + ``` + <1> If you need to initialize archive storage, add `-e ARCHIVE=true`. + + {{< info >}} + While initializing with ILM support, make sure that an ILM policy named `jaeger-ilm-policy` is created in Elasticsearch beforehand (see the previous step), otherwise the following error message will be shown: + + "ILM policy jaeger-ilm-policy doesn't exist in Elasticsearch. Please create it and rerun init" + {{< /info >}} + + After the initialization, deploy Jaeger with `--es.use-ilm=true` and `--es.use-aliases=true`. + + +#### Upgrade Elasticsearch version + +Elasticsearch defines wire and index compatibility versions. The index compatibility defines +the minimal version a node can read data from. For example Elasticsearch 8 can read indices +created by Elasticsearch 7, however it cannot read indices created by Elasticsearch 6 even +though they use the same index mappings. Therefore upgrade from Elasticsearch 7 to 8 does not require any +data migration. However, upgrade from Elasticsearch 6 to 8 has to be done through Elasticsearch 7 and wait +until indices created by ES 6.x are removed or explicitly reindexed. + +Refer to the Elasticsearch [documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current//setup-upgrade.html) +for wire and index compatibility versions. Generally this information can be retrieved from root/ping REST endpoint. + +##### Reindex + +Manual reindexing can be used when upgrading from Elasticsearch 6 to 8 (through Elasticsearch 7) +without waiting until indices created by Elasticsearch 6 are removed. + +1. Reindex all span indices to new indices with suffix `-1`: + + ```bash + curl -ivX POST -H "Content-Type: application/json" http://localhost:9200/_reindex -d @reindex.json + { + "source": { + "index": "jaeger-span-*" + }, + "dest": { + "index": "jaeger-span" + }, + "script": { + "lang": "painless", + "source": "ctx._index = 'jaeger-span-' + (ctx._index.substring('jaeger-span-'.length(), ctx._index.length())) + '-1'" + } + } + ``` + +2. Delete indices with old mapping: + + ```bash + curl -ivX DELETE -H "Content-Type: application/json" http://localhost:9200/jaeger-span-\*,-\*-1 + ``` + +3. Create indices without `-1` suffix: + + ```bash + curl -ivX POST -H "Content-Type: application/json" http://localhost:9200/_reindex -d @reindex.json + { + "source": { + "index": "jaeger-span-*" + }, + "dest": { + "index": "jaeger-span" + }, + "script": { + "lang": "painless", + "source": "ctx._index = 'jaeger-span-' + (ctx._index.substring('jaeger-span-'.length(), ctx._index.length() - 2))" + } + } + ``` + +4. Remove suffixed indices: + + ```bash + curl -ivX DELETE -H "Content-Type: application/json" http://localhost:9200/jaeger-span-\*-1 + ``` + +Run the commands analogically for other Jaeger indices. + +There might exist more effective migration procedure. Please share with the community any findings. + +### Kafka +* Supported in Jaeger since 1.6.0 +* Supported Kafka versions: 0.9+ + +Kafka can be used as an intermediary buffer between collector and an actual storage. +**jaeger-collector** is configured with `SPAN_STORAGE_TYPE=kafka` that makes it write all received spans +into a Kafka topic. [**jaeger-ingester**](#ingester) is used to read from +Kafka and store spans in another storage backend (Elasticsearch or Cassandra). + +Writing to Kafka is particularly useful for building post-processing data pipelines. + +#### Configuration +##### Minimal +```sh +docker run \ + -e SPAN_STORAGE_TYPE=kafka \ + -e KAFKA_PRODUCER_BROKERS=<...> \ + -e KAFKA_TOPIC=<...> \ + jaegertracing/jaeger-collector:{{< currentVersion >}} +``` + +##### All options +To view the full list of configuration options, you can run the following command: +```sh +docker run \ + -e SPAN_STORAGE_TYPE=kafka \ + jaegertracing/jaeger-collector:{{< currentVersion >}} \ + --help +``` + +#### Topic & partitions +Unless your Kafka cluster is configured to automatically create topics, you will need to create it ahead of time. You can refer to [the Kafka quickstart documentation](https://kafka.apache.org/documentation/#quickstart_createtopic) to learn how. + +You can find more information about topics and partitions in general in the [official documentation](https://kafka.apache.org/documentation/#intro_topics). [This article](https://www.confluent.io/blog/how-to-choose-the-number-of-topicspartitions-in-a-kafka-cluster/) provide more details about how to choose the number of partitions. + +### Remote Storage + +Jaeger supports a gRPC-based [Remote Storage API][storage.proto] that allows extending the Jaeger ecosystem with custom storage backends, not directly supported by the project. These storage backends can be deployed as a remote gRPC server (since Jaeger v1.30). Older deployment mode as sidecar plugin will not be supported starting from v1.58. + +To use a remote storage as Jaeger storage backend, use `grpc` as the storage type and specify the remote gRPC server address. For more information, please refer to [jaeger/plugin/storage/grpc](https://github.com/jaegertracing/jaeger/tree/master/plugin/storage/grpc). + +Example: +```sh +docker run \ + -e SPAN_STORAGE_TYPE=grpc \ + -e GRPC_STORAGE_SERVER=<...> \ + jaegertracing/all-in-one:{{< currentVersion >}} +``` + +Known remote storage backends: + +* [PostgreSQL by robbert229](https://github.com/robbert229/jaeger-postgresql) + +## Metrics Storage Backends + +Jaeger Query is capable of querying aggregated R.E.D metrics from a storage backend, +visualizing them on the [Monitor tab](../spm). It should be emphasized that the +configured metrics storage type is for reading _only_ and therefore, only applies +to the Jaeger Query component (and All In One, which contains Jaeger Query). + +The storage type can be passed via `METRICS_STORAGE_TYPE` environment variable. +Valid values are: `prometheus`. + +### Prometheus + +Any PromQL-compatible backend is supported by Jaeger Query. A list of these have +been compiled by Julius Volz in: +https://promlabs.com/blog/2020/11/26/an-update-on-promql-compatibility-across-vendors + +#### Configuration + +##### Minimal +```sh +docker run \ + -e METRICS_STORAGE_TYPE=prometheus \ + jaegertracing/jaeger-query:{{< currentVersion >}} +``` + +##### All options +To view the full list of configuration options, you can run the following command: +```sh +docker run \ + -e METRICS_STORAGE_TYPE=prometheus \ + jaegertracing/jaeger-query:{{< currentVersion >}} \ + --help +``` +#### TLS support + +Jaeger supports TLS client to Prometheus server connections as long as you've [configured +your Prometheus server](https://prometheus.io/docs/guides/tls-encryption/) correctly. You can +configure **jaeger-query** like so: + +```sh +docker run \ + -e METRICS_STORAGE_TYPE=prometheus \ + -e PROMETHEUS_SERVER_URL=<...> \ + -e PROMETHEUS_TLS_ENABLED=true \ + -e PROMETHEUS_TLS_CA= \ + jaegertracing/jaeger-query:{{< currentVersion >}} +``` + +## Aggregation Jobs for Service Dependencies + +Production deployments need an external process that aggregates data and creates dependency links between services. Project [spark-dependencies](https://github.com/jaegertracing/spark-dependencies) is a Spark job which derives dependency links and writes them directly to the storage. + +[cqlsh]: http://cassandra.apache.org/doc/latest/tools/cqlsh.html +[zipkin-thrift]: https://github.com/jaegertracing/jaeger-idl/blob/master/thrift/zipkincore.thrift +[jaeger-thrift]: https://github.com/jaegertracing/jaeger-idl/blob/master/thrift/jaeger.thrift +[model.proto]: https://github.com/jaegertracing/jaeger-idl/blob/main/proto/api_v2/model.proto +[thriftrw]: https://www.npmjs.com/package/thriftrw +[storage.proto]: https://github.com/jaegertracing/jaeger/blob/main/plugin/storage/grpc/proto/storage.proto +[otlp]: https://github.com/open-telemetry/opentelemetry-proto/blob/main/docs/specification.md diff --git a/content/docs/1.61/external-guides.md b/content/docs/1.61/external-guides.md new file mode 100644 index 00000000..ae89605f --- /dev/null +++ b/content/docs/1.61/external-guides.md @@ -0,0 +1,38 @@ +--- +title: External Guides +description: Guides hosted outside of the main Jaeger documentation. +weight: 13 +--- + +## Using Jaeger + +* [Take Jaeger for a HotROD ride](https://medium.com/jaegertracing/take-jaeger-for-a-hotrod-ride-233cf43e46c2) by Yuri Shkuro +* [Trace comparisons](https://medium.com/jaegertracing/trace-comparisons-arrive-in-jaeger-1-7-a97ad5e2d05d) by Joe Farro + +## Success stories + +* [Weaveworks Combines Jaeger Tracing With Logs and Metrics for a Troubleshooting Swiss Army Knife](https://medium.com/jaegertracing/weaveworks-combines-jaeger-tracing-with-logs-and-metrics-for-a-troubleshooting-swiss-army-knife-5afc0f42b22e) by Orate +* [Grafana Labs Teams Use Jaeger to Improve Query Performance Up to 10x](https://medium.com/jaegertracing/grafana-labs-teams-observed-query-performance-improvements-up-to-10x-with-jaeger-cec84b0e3609) by Orate +* [Ticketmaster Traces 100 Million Transactions per Day with Jaeger](https://medium.com/jaegertracing/ticketmaster-traces-100-million-transactions-per-day-with-jaeger-38ec6cf599f0) by Orate + +## Architecture & Concepts + +* [The life of a span](https://medium.com/jaegertracing/the-life-of-a-span-ee508410200b) by Juraci Paixão Kröhling +* Sampling - content needed +* [Adaptive Sampling](https://medium.com/jaegertracing/adaptive-sampling-in-jaeger-50f336f4334) by Yuri Shkuro and Joe Elliot + +## Deployment + +* [Running Jaeger on bare metal](https://medium.com/jaegertracing/running-jaeger-agent-on-bare-metal-d1fc47d31fab) by Juraci Paixão Kröhling +* [Protecting Jaeger UI with an OAuth sidecar Proxy](https://medium.com/jaegertracing/protecting-jaeger-ui-with-an-oauth-sidecar-proxy-34205cca4bb1) by Juraci Paixão Kröhling +* [Jaeger and multi-tenancy](https://medium.com/jaegertracing/jaeger-and-multitenancy-99dfa1d49dc0) by Juraci Paixão Kröhling +* [Deployment strategies for the Jaeger Agent](https://medium.com/jaegertracing/deployment-strategies-for-the-jaeger-agent-1d6f91796d09) by Juraci Paixão Kröhling +* [How to deploy Jaeger on AWS: a comprehensive step-by-step guide](https://www.aspecto.io/blog/how-to-deploy-jaeger-on-aws-a-comprehensive-step-by-step-guide/) by Tom Zach + +## Jaeger Performance Tuning + +* [How to maximize span ingestion while limiting writes per second to Scylla with Jaeger](https://medium.com/jaegertracing/how-to-maximize-span-ingestion-while-limiting-writes-per-second-to-scylla-with-jaeger-3bcda5608841) by Joe Elliott + +## Troubleshooting + +* [Where did all my spans go? A guide to diagnosing dropped spans in Jaeger](https://medium.com/jaegertracing/where-did-all-my-spans-go-a-guide-to-diagnosing-dropped-spans-in-jaeger-10d9697f8182) by Joe Elliott diff --git a/content/docs/1.61/faq.md b/content/docs/1.61/faq.md new file mode 100644 index 00000000..ac330bc3 --- /dev/null +++ b/content/docs/1.61/faq.md @@ -0,0 +1,71 @@ +--- +title: Frequently Asked Questions +navtitle: FAQs +description: Answers to some frequently asked questions about Jaeger. +weight: 11 +--- + +## Why is the Dependencies page empty? + +The Dependencies page shows a graph of services traced by Jaeger and connections between them. When you are using `all-in-one` binary with in-memory storage, the graph is calculated on-demand from all the traces stored in memory. However, if you are using real distributed storage like Cassandra or OpenSearch/Elasticsearch, it is too expensive to scan all the data in the database to build the service graph. Instead, the Jaeger project provides "big data" jobs that can be used to extract the service graph data from traces: + + * https://github.com/jaegertracing/spark-dependencies - the older Spark job that can be run periodically + * https://github.com/jaegertracing/jaeger-analytics - the new (experimental) streaming Flink jobs that run continuously and builds the service graph in smaller time intervals + +## Why do I not see any spans in Jaeger? + +Please refer to the [Troubleshooting](../troubleshooting/) guide. + +## Do I need to run jaeger-agent? + +{{< warning >}} +Since the Jaeger client libraries [are deprecated](../client-libraries) and the OpenTelemetry SDKs are phasing out support for Jaeger Thrift format, the **jaeger-agent** is no longer required or recommended. See the [Architecture](../architecture) page for alternative deployment options. +{{< /warning >}} + +`jaeger-agent` is not always necessary. Jaeger client libraries can be configured to export trace data directly to `jaeger-collector`. However, the following are the reasons why running `jaeger-agent` is recommended: + + * If we want Jaeger client libraries to send trace data directly to **jaeger-collector**s, we must provide them with a URL of the HTTP endpoint. It means that our applications require additional configuration containing this parameter, especially if we are running multiple Jaeger installations (e.g. in different availability zones or regions) and want the data sent to a nearby installation. In contrast, when using the agent, the libraries require no additional configuration because the agent is always accessible via `localhost`. It acts as a sidecar and proxies the requests to the appropriate **jaeger-collector**s. + * **jaeger-agent** can be configured to enrich the tracing data with infrastructure-specific metadata by adding extra tags to the spans, such as the current zone, region, etc. If **jaeger-agent** is running as a host daemon, it will be shared by all applications running on the same host. If **jaeger-agent** is running as a true sidecar, i.e. one per application, it can provide additional functionality such as strong authentication, multi-tenancy (see [this blog post](https://medium.com/jaegertracing/jaeger-and-multitenancy-99dfa1d49dc0)), pod name, etc. + * **jaeger-agent**s allow implementing traffic control to **jaeger-collector**s. If we have thousands of hosts in the data center, each running many applications, and each application sending data directly to **jaeger-collector**s, there may be too many open connections for each **jaeger-collector** to handle. The agents can load balance this traffic with fewer connections. + +## What is the recommended storage backend? + +The Jaeger team recommends OpenSearch/Elasticsearch as the storage backend over Cassandra, for the following reasons: + + * Cassandra is a key-value database, so it is more efficient for retrieving traces by trace ID, but it does not provide the same powerful search capabilities as OpenSearch. Effectively, the Jaeger backend implements the search functionality on the client side, on top of k-v storage, which is limited and may produce inconsistent results (see [issue-166][issue-166] for more details). OpenSearch does not suffer from these issues, resulting in better usability. OpenSearch can also be queried directly, e.g. from Kibana dashboards, and provide useful analytics and aggregations. + + * Based on past performance experiments we observed single writes to be much faster in Cassandra than OpenSearch, which might suggest that it may sustain higher write throughput. However, because the Jaeger backend needs to implement search capability on top of k-v storage, writing spans to Cassandra is actually subject to large write amplification: in addition to writing a record for the span itself, Jaeger performs extra writes for service name and operation name indexing, as well as extra index writes for every tag. In contrast, saving a span to OpenSearch is a single write, and all indexing takes place inside the OpenSearch node. As a result, the overall throughput to Cassandra is comparable with OpenSearch. + +One benefit of Cassandra backend is simplified maintenance due to its native support for data TTL. In OpenSearch the data expiration is managed through index rotation, which requires additional setup (see [Elasticsearch Rollover](../deployment/#elasticsearch-rollover)). + +[issue-166]: https://github.com/jaegertracing/jaeger/issues/166 + +## Why do Jaeger trace IDs look differently in Kafka and in the UI? + +Under the hood, at the data model level, the Jaeger trace IDs are a sequence of 16 bytes. However, these 16 bytes can be represented in many different ways: + + * in the UI, we historically represented them as hex-encoded strings, e.g., `7e90c0eca22784ec7e90c0eca22784ec`. These strings can be either 32 characters long when using the 128-bit IDs (as more common in OpenTelemetry), or 16 characters if the IDs are generated in the legacy 64-bit mode. + * in the [domain model][trace-id-domain] in the Jaeger backend code, we represent trace ID as a pair of unsigned 64-bit integers using big-endian encoding. This was done for efficiency because a byte slice in Go requires an extra memory allocation. + * in the original [Thrift model][trace-id-thrift] we also represented them as a pair of unsigned 64-bit integers + * in the [Protobuf model][trace-id-proto], the ID is represented as a byte sequence. When Protobuf is serialized as a binary payload, these bytes are transmitted as is. However, Protobuf also supports a JSON encoding, where byte sequences are serialized using base64 encoding. So if you configure collector-Kafka-ingester pipeline to use the JSON encoding, you will see trace IDs that look like `fpDA7KInhOx+kMDsoieE7A==`. These can be converted to hex-encoded IDs that are recognized by the UI using online tools like https://base64.guru/converter/encode/hex. + +[trace-id-domain]: https://github.com/jaegertracing/jaeger/blob/7872d1b07439c3f2d316065b1fd53e885b26a66f/model/ids.go#L82 +[trace-id-thrift]: https://github.com/jaegertracing/jaeger-idl/blob/05fe64e9c305526901f70ff692030b388787e388/thrift/jaeger.thrift#L53 +[trace-id-proto]: https://github.com/jaegertracing/jaeger-idl/blob/05fe64e9c305526901f70ff692030b388787e388/proto/api_v2/model.proto#L97 + +## Do I need to run multiple collectors? + +> Does having high availability of **jaeger-collector** improve the overall system performance like decreasing the dropped span count and having the less outage for trace collection? Is it recommended? If yes, why? + +These are the reasons to run multiple instances: + * Your clients send so much data that a single **jaeger-collector** is not able to accept it fast enough. + * You want higher availability, e.g., when you do rolling restarts of **jaeger-collector**s for upgrade, to have some instances still running and able to process inbound data. + +These are NOT the reasons to run multiple instances: + * To avoid data loss. **jaeger-collector** drops data when the backend storage is not able to save it fast enough. Increasing the number of **jaeger-collector**s, with more memory allocated to their internal queues, could provide a small, temporary relief, but does not remove the bottleneck of the storage backend. + +## How do I configure authentication for Jaeger UI + +Jaeger UI does not support any notion of accounts or roles, so there is no need to authenticate the users. If you need authentication in order to simply restrict who can access Jaeger UI, we recommend running a reverse proxy in front of it, such as HAProxy, NGINX, Keycloak, etc. The advantage of using standard reverse proxies is that they support a wide variety of integrations with various authentication and single sign-on services, something we would never be able to match in Jaeger UI. + +For example, refer to this blog post for an example of [protecting Jaeger UI with Keycloak](https://medium.com/jaegertracing/protecting-jaeger-ui-with-an-oauth-sidecar-proxy-34205cca4bb1). diff --git a/content/docs/1.61/features.md b/content/docs/1.61/features.md new file mode 100644 index 00000000..f76b5a32 --- /dev/null +++ b/content/docs/1.61/features.md @@ -0,0 +1,77 @@ +--- +title: Features +hasparent: true +--- + +## High Scalability + +Jaeger backend is designed to have no single points of failure and to scale with the business needs. +For example, any given Jaeger installation at Uber is typically processing several billion spans per day. + +## Native support for OpenTracing and OpenTelemetry + +Jaeger backend, Web UI, and instrumentation libraries have been designed from ground up to support the OpenTracing standard. + +* Represent traces as directed acyclic graphs (not just trees) via [span references](https://github.com/opentracing/specification/blob/master/specification.md#references-between-spans) +* Support strongly typed span _tags_ and _structured logs_ + +Since v1.35, the Jaeger backend can receive trace data from the OpenTelemetry SDKs in their native [OpenTelemetry Protocol (OTLP)][otlp]. However, the internal data representation and the UI still follow the OpenTracing specification's model. + +## Multiple storage backends + +Jaeger can be used with a growing number of storage backends: +* It natively supports popular open source NoSQL databases as trace storage backends: Cassandra 3.4+, Elasticsearch 7.x/8.x, and OpenSearch 1.0+. +* It integrates via a gRPC API with other well known databases that have been certified to be Jaeger compliant: [ClickHouse](https://github.com/jaegertracing/jaeger-clickhouse). +* There is embedded database support using [Badger](https://github.com/dgraph-io/badger) and simple in-memory storage for testing setups. +* There are ongoing community experiments using other databases; you can find more in [this issue](https://github.com/jaegertracing/jaeger/issues/638). + +## Modern Web UI + +Jaeger Web UI is implemented in Javascript using popular open source frameworks like React. Several performance improvements have been released in v1.0 to allow the UI to efficiently deal with large volumes of data and display traces with tens of thousands of spans (e.g. we tried a trace with 80,000 spans). + +## Cloud Native Deployment + +Jaeger backend is distributed as a collection of Docker images. The binaries support various configuration methods, +including command line options, environment variables, and configuration files in multiple formats (yaml, toml, etc.). +Deployment to Kubernetes clusters is assisted by a [Kubernetes operator](https://github.com/jaegertracing/jaeger-operator) +and a [Helm chart](https://github.com/kubernetes/charts/tree/master/incubator/jaeger). + +## Observability + +All Jaeger backend components expose [Prometheus](https://prometheus.io/) metrics by default. +Logs are written to stdout using the structured logging library [zap](https://github.com/uber-go/zap). + +## Backwards compatibility with Zipkin + +Although we recommend instrumenting applications with OpenTelemetry, if your organization has already invested in the instrumentation using Zipkin libraries, you do not have to rewrite all that code. Jaeger provides backwards compatibility with Zipkin by accepting spans in Zipkin formats (Thrift, JSON v1/v2 and Protobuf) over HTTP. Switching from a Zipkin backend is just a matter of routing the traffic from Zipkin libraries to the Jaeger backend. + +## Topology Graphs + +Jaeger UI supports two types of service graphs: **System Architecture** and **Deep Dependency Graph**. + +### System Architecture + +The "classic" service dependency graph for all services observed in the architecture. The graph represents only one-hop dependencies between services, similar to what one could get from telemetry produced by service meshes. For example, a graph `A - B - C` means that there are some traces that contain network calls between `A` and `B`, and some traces with calls between `B` and `C`. However, it does not mean there are any traces that contain the full chain `A - B - C`, i.e. we cannot say that `A` depends on `C`. + +The node granularity of this graph is services only, not service endpoints. + +The System Architecture graph can be built on the fly from in-memory storage, or by using Spark or Flink jobs when using distributed storage. + +### Deep Dependency Graph + +Also known as "Transitive Dependency Graph", where a chain `A -> B -> C` means that `A` has a transitive dependency on `C`. A single graph requires a "focal" service (shown in pink) and only displays the paths passing through that service. Typically, this type of graph does not represent the full architecture of the system, unless there is a service that is connected to everything, e.g. an API gateway, and it is selected as a focal service. + +The node granularity of this graph can be changed between services and service endpoints. In the latter mode, different endpoints in the same service will be displayed as separate nodes, e.g. `A::op1` and `A::op2`. + +At this time the transitive graph can only be constructed from traces in the search results. In the future there will be a Flink job that will compute the graphs by aggregating all traces. + +## Service Performance Monitoring (SPM) + +Visualizes aggregated span data in the form of RED (Requests, Errors, Duration) metrics +to highlight services and/or operations with statistically significant request/error rates or +latencies, then leveraging Jaeger's Trace Search capabilities to pinpoint specific +traces belonging to these services/operations. + +See [Service Performance Monitoring (SPM)](../spm) for more details. + +[otlp]: https://opentelemetry.io/docs/reference/specification/protocol/ diff --git a/content/docs/1.61/frontend-ui.md b/content/docs/1.61/frontend-ui.md new file mode 100644 index 00000000..010e1b33 --- /dev/null +++ b/content/docs/1.61/frontend-ui.md @@ -0,0 +1,265 @@ +--- +title: Frontend/UI Configuration +navtitle: Frontend/UI +hasparent: true +weight: 7 +--- + +## Configuration + +Several aspects of the UI can be configured: + + * The Dependencies section can be enabled / configured + * The [Monitor tab (aka: Service Performance Monitoring)](../spm) can be enabled / configured + * App analytics tracking can be enabled / configured (via Google Analytics or custom plugin) + * Additional menu options can be added to the global nav + * Search input limits can be configured + +These options can be configured by a JSON configuration file. The `--query.ui-config` command line parameter of the query service must then be set to the path to the JSON file when the query service is started. + +An example configuration file (see [complete schema here](https://github.com/jaegertracing/jaeger-ui/blob/main/packages/jaeger-ui/src/types/config.tsx)): + +```json +{ + "dependencies": { + "dagMaxNumServices": 200, + "menuEnabled": true + }, + "monitor": { + "menuEnabled": true + }, + "archiveEnabled": true, + "tracking": { + "gaID": "UA-000000-2", + "trackErrors": true + }, + "menu": [ + { + "label": "About Jaeger", + "items": [ + { + "label": "GitHub", + "url": "https://github.com/jaegertracing/jaeger" + }, + { + "label": "Docs", + "url": "http://jaeger.readthedocs.io/en/latest/" + } + ] + } + ], + "search": { + "maxLookback": { + "label": "2 Days", + "value": "2d" + }, + "maxLimit": 1500 + }, + "linkPatterns": [{ + "type": "process", + "key": "jaeger.version", + "url": "https://github.com/jaegertracing/jaeger-client-java/releases/tag/#{jaeger.version}", + "text": "Information about Jaeger release #{jaeger.version}" + }, + { + "type": "tags", + "key": "uniqueId", + "url": "https://mykibana.com/uniqueId=#{uniqueId}&traceId=#{trace.traceID}", + "text": "Redirect to kibana to view log" + }] +} +``` + +### Dependencies + +`dependencies.dagMaxNumServices` defines the maximum number of services allowed before the DAG dependency view is disabled. Default: `200`. + +`dependencies.menuEnabled` enables (`true`) or disables (`false`) the dependencies menu button. Default: `true`. + +### Monitor + +`monitor.menuEnabled` enables (`true`) or disables (`false`) the Monitor menu button. Default: `false`. + +### Archive Support + +`archiveEnabled` enables (`true`) or disables (`false`) the archive traces button. Default: `false`. It requires a configuration of an archive storage in Query service. Archived traces are only accessible directly by ID, they are not searchable. + +### App Analytics Tracking + +`tracking.gaID` defines the Google Analytics tracking ID. This is required for Google Analytics tracking, and setting it to a non-`null` value enables Google Analytics tracking. Default: `null`. + +`tracking.customWebAnalytics` defines a factory function for a custom tracking plugin (only when using Javascript-form of UI configuration). + +`tracking.trackErrors` enables (`true`) or disables (`false`) error tracking. Errors can only be tracked if a valid analytics tracker is configured. Default: `true`. + +For additional details on app analytics see the [tracking README](https://github.com/jaegertracing/jaeger-ui/blob/master/packages/jaeger-ui/src/utils/tracking/README.md) in the UI repo. + +### Custom Menu Items + +`menu` allows additional links to be added to the global nav. The additional links are right-aligned. + +In the sample JSON config above, the configured menu will have a dropdown labeled "About Jaeger" with sub-options for "GitHub" and "Docs". The format for a link in the top right menu is as follows: + +```json +{ + "label": "Some text here", + "url": "https://example.com" +} +``` + +Links can either be members of the `menu` Array, directly, or they can be grouped into a dropdown menu option. The format for a group of links is: + +```json +{ + "label": "Dropdown button", + "items": [ ] +} +``` + +The `items` Array should contain one or more link configurations. + +### Search Input Limit + +The `search.maxLimit` configures the maximum results that the input let you search. + +The `search.maxLookback` configures the maximum time before the present users can query for traces. The options in the Lookback dropdown greater than this value will not be shown. + +Field | Description +------|------------ +label | The text displayed in the search form dropdown +value | The value submitted in the search query if the label is selected + +### Link Patterns + +The `linkPatterns` node can be used to create links from fields displayed in the Jaeger UI. + +Field | Description +------|------------ +type | The metadata section in which your link will be added: process, tags, logs, traces +key | The name of tag/process/log attribute which value will be displayed as a link, this field is not necessary for type `traces`. +url | The URL where the link should point to, it can be an external site or relative path in Jaeger UI +text | The text displayed in the tooltip for the link + +Both `url` and `text` can be defined as templates (i.e. using `#{field-name}`) where Jaeger UI will dynamically substitute values based on tags/logs/traces data. + +For traces, the supported template fields are: `duration`, `endTime`, `startTime`, `traceName` and `traceID`. + +Further, the trace template fields are available for substitution in process/logs/tags type when the trace template fields are prefixed with `trace.`. For example: `trace.traceID`, `trace.startTime`. + +## Embedded Mode + +Starting with version 1.9, Jaeger UI provides an "embedded" layout mode which is intended to support integrating Jaeger UI into other applications. Currently (as of `v0`), the approach taken is to remove various UI elements from the page to make the UI better suited for space-constrained layouts. + +The embedded mode is induced and configured via URL query parameters. + +To enter embedded mode, the `uiEmbed=v0` query parameter and value must be added to the URL. For example, the following URL will show the trace with ID `abc123` in embedded mode: + +``` +http://localhost:16686/trace/abc123?uiEmbed=v0 +``` + +`uiEmbed=v0` is required. + +Further, each page supported has an Embed open window button added that will open the non-embedded page in a new tab. + +The following pages support embedded mode: + +* Search Page +* Trace Page + +### Search Page + +To integrate the Search Trace Page to our application we have to indicate to the Jaeger UI that we want to use the embed mode with `uiEmbed=v0`. + +For example: + +``` +http://localhost:16686/search? + service=my-service& + start=1543917759557000& + end=1543921359557000& + limit=20& + lookback=1h& + maxDuration& + minDuration& + uiEmbed=v0 +``` + +![Embed Search Traces](/img/frontend-ui/embed-search-traces.png) + +#### Configuration options + +The following query parameter can be used to configure the layout of the search page : + +* `uiSearchHideGraph=1` - disables the display of the scatter plot above the search results + +``` +http://localhost:16686/search? + service=my-service& + start=1543917759557000& + end=1543921359557000& + limit=20& + lookback=1h& + maxDuration& + minDuration& + uiEmbed=v0& + uiSearchHideGraph=1 +``` + +![Embed Search Traces without Graph](/img/frontend-ui/embed-search-traces-hide-graph.png) + +### Trace Page + + +To integrate the Trace Page to our application we have to indicate to the Jaeger UI that we want to use the embed mode with `uiEmbed=v0`. + +For example: + +```sh +http://localhost:16686/trace/{trace-id}?uiEmbed=v0 +``` +![Embed Trace view](/img/frontend-ui/embed-trace-view.png) + +If we have navigated to this view from the search traces page we'll have a button to go back to the results page. + +![Embed Trace view](/img/frontend-ui/embed-trace-view-with-back-button.png) + +#### Configuration options + +The following query parameters can be used to configure the layout of the trace page : + +* `uiTimelineCollapseTitle=1` causes the trace header to start out collapsed, which hides the summary and the minimap. + +``` +http://localhost:16686/trace/{trace-id}? + uiEmbed=v0& + uiTimelineCollapseTitle=1 +``` +![Embed Trace view](/img/frontend-ui/embed-trace-view-with-collapse.png) + +* `uiTimelineHideMinimap=1` removes the minimap, entirely, regardless of whether the trace header is expanded or not. + +``` +http://localhost:16686/trace/{trace-id}? + uiEmbed=v0& + uiTimelineHideMinimap=1 +``` +![Embed Trace view](/img/frontend-ui/embed-trace-view-with-hide-minimap.png) + +* `uiTimelineHideSummary=1` - removes the trace summary information (number of services, etc.) entirely, regardless of whether the trace header is expanded or not. + +``` +http://localhost:16686/trace/{trace-id}? + uiEmbed=v0& + uiTimelineHideSummary=1 +``` +![Embed Trace view](/img/frontend-ui/embed-trace-view-with-hide-summary.png) + +We can also combine the options: +``` +http://localhost:16686/trace/{trace-id}? + uiEmbed=v0& + uiTimelineHideMinimap=1& + uiTimelineHideSummary=1 +``` +![Embed Trace view](/img/frontend-ui/embed-trace-view-with-hide-details-and-hide-minimap.png) diff --git a/content/docs/1.61/getting-started.md b/content/docs/1.61/getting-started.md new file mode 100644 index 00000000..9423ea38 --- /dev/null +++ b/content/docs/1.61/getting-started.md @@ -0,0 +1,147 @@ +--- +title: Getting Started +description: Get up and running with Jaeger in your local environment +weight: 2 +--- + +If you are new to distributed tracing, please check the [Introduction](../) page. + +## Instrumentation + +Your applications must be instrumented before they can send tracing data to Jaeger. We recommend using the [OpenTelemetry][otel] instrumentation and SDKs. + +Historically, the Jaeger project supported its own SDKs (aka tracers, client libraries) that implemented the OpenTracing API. As of 2022, the Jaeger SDKs are no longer supported, and all users are advised to migrate to OpenTelemetry. + +## All in One + +**all-in-one** is an executable designed for quick local testing. It includes the Jaeger UI, **jaeger-collector**, **jaeger-query**, and **jaeger-agent**, with an in memory storage component. + +The simplest way to start the all-in-one is to use the pre-built image published to DockerHub (a single command line). + +```bash +docker run --rm --name jaeger \ + -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 \ + -p 6831:6831/udp \ + -p 6832:6832/udp \ + -p 5778:5778 \ + -p 16686:16686 \ + -p 4317:4317 \ + -p 4318:4318 \ + -p 14250:14250 \ + -p 14268:14268 \ + -p 14269:14269 \ + -p 9411:9411 \ + jaegertracing/all-in-one:{{< currentVersion >}} +``` + +Or run the `jaeger-all-in-one(.exe)` executable from the [binary distribution archives][download]: + +```bash +jaeger-all-in-one --collector.zipkin.host-port=:9411 +``` + +You can then navigate to `http://localhost:16686` to access the Jaeger UI. + +The container exposes the following ports: + +Port | Protocol | Component | Function +----- | ------- | --------- | --- +6831 | UDP | agent | accept `jaeger.thrift` over Thrift-compact protocol (used by most SDKs) +6832 | UDP | agent | accept `jaeger.thrift` over Thrift-binary protocol (used by Node.js SDK) +5775 | UDP | agent | (deprecated) accept `zipkin.thrift` over compact Thrift protocol (used by legacy clients only) +5778 | HTTP | agent | serve configs (sampling, etc.) + | | | +16686 | HTTP | query | serve frontend + | | | +4317 | HTTP | collector | accept OpenTelemetry Protocol (OTLP) over gRPC +4318 | HTTP | collector | accept OpenTelemetry Protocol (OTLP) over HTTP +14268 | HTTP | collector | accept `jaeger.thrift` directly from clients +14250 | HTTP | collector | accept `model.proto` +9411 | HTTP | collector | Zipkin compatible endpoint (optional) + + +### With Service Performance Monitoring (SPM) + +Please refer to [Service Performance Monitoring (SPM)](../spm#getting-started). + +## On Kubernetes + +Please see Kubernetes Operator: https://github.com/jaegertracing/jaeger-operator + +## Sample App: HotROD + +HotROD (Rides on Demand) is a demo application that consists of several microservices and illustrates +the use of [OpenTelemetry][otel] and distributed tracing. A tutorial / walkthrough is available in the blog post: +[Take Jaeger for a HotROD ride][hotrod-tutorial]. + +The HotROD app can be run standalone, but requires Jaeger backend to view the traces. + +### Features + +- Discover architecture of the whole system via data-driven dependency + diagram. +- View request timeline and errors; understand how the app works. +- Find sources of latency and lack of concurrency. +- Highly contextualized logging. +- Use baggage propagation to diagnose inter-request contention (queueing) and time spent in a service. +- Use open source libraries from `opentelemetry-contrib` to get vendor-neutral instrumentation for free. + +### Running + +We recommend running Jaeger and HotROD together via `docker compose`. + + +#### With Docker Compose + +```bash +git clone git@github.com:jaegertracing/jaeger.git jaeger +cd jaeger/examples/hotrod +docker compose up +# Ctrl-C to stop +``` + +#### With Docker + +```bash +docker run --rm -it --link jaeger \ + -p8080-8083:8080-8083 \ + -e OTEL_EXPORTER_OTLP_ENDPOINT="http://jaeger:4318" \ + jaegertracing/example-hotrod:{{< currentVersion >}} \ + all --otel-exporter=otlp +``` + +#### From Source + +In order to run from source you need: + +- [Go toolchain](https://golang.org/doc/install) installed on your machine + (see [go.mod](https://github.com/jaegertracing/jaeger/blob/master/go.mod) file for minimum required Go version). +- A [running Jaeger backend](#all-in-one) to view the traces. + +```bash +git clone git@github.com:jaegertracing/jaeger.git jaeger +cd jaeger +go run ./examples/hotrod/main.go all +``` + +#### From binary distribution + +Run `example-hotrod(.exe)` executable from the [binary distribution archives][download]: +```bash +example-hotrod all +``` + +Then navigate to `http://localhost:8080`. + + +## Migrating from Zipkin + +**jaeger-collector** service exposes Zipkin compatible REST API `/api/v1/spans` which accepts both Thrift and JSON. Also there is `/api/v2/spans` for JSON and Proto. +By default it's disabled. It can be enabled with `--collector.zipkin.host-port=:9411`. + +Zipkin [Thrift](https://github.com/jaegertracing/jaeger-idl/blob/master/thrift/zipkincore.thrift) IDL and Zipkin [Proto](https://github.com/jaegertracing/jaeger-idl/blob/master/proto/zipkin.proto) IDL files can be found in [jaegertracing/jaeger-idl](https://github.com/jaegertracing/jaeger-idl) repository. +They're compatible with [openzipkin/zipkin-api](https://github.com/openzipkin/zipkin-api) [Thrift](https://github.com/openzipkin/zipkin-api/blob/master/thrift/zipkinCore.thrift) and [Proto](https://github.com/openzipkin/zipkin-api/blob/master/zipkin.proto). + +[hotrod-tutorial]: https://medium.com/jaegertracing/take-jaeger-for-a-hotrod-ride-233cf43e46c2 +[otel]: https://opentelemetry.io +[download]: ../../../download/ diff --git a/content/docs/1.61/monitoring.md b/content/docs/1.61/monitoring.md new file mode 100644 index 00000000..8e82b6e3 --- /dev/null +++ b/content/docs/1.61/monitoring.md @@ -0,0 +1,48 @@ +--- +title: Monitoring Jaeger +navtitle: Monitoring +weight: 8 +--- + +Jaeger itself is a distributed, microservices based system. If you run it in production, you will likely want to setup adequate monitoring for different components, e.g. to ensure that the backend is not saturated by too much tracing data. + +## Metrics + +By default Jaeger microservices expose metrics in Prometheus format. It is controlled by the following command line options: + +* `--admin.http.host-port` the port number where the HTTP admin server is running +* `--metrics-backend` controls how the measurements are exposed. The default value is `prometheus`, another option is `expvar`, the Go standard mechanism for exposing process level statistics. +* `--metrics-http-route` specifies the name of the HTTP endpoint used to scrape the metrics (`/metrics` by default). + +Each Jaeger component exposes the metrics scraping endpoint on the admin port: + +Component | Port +--------------------- | --- +**jaeger-agent** | 14271 +**jaeger-collector** | 14269 +**jaeger-query** | 16687 +**jaeger-ingester** | 14270 +**all-in-one** | 14269 + +### Prometheus monitoring mixin for Jaeger + +The Prometheus monitoring mixin for Jaeger provides a starting point for people wanting to monitor Jaeger using Prometheus, Alertmanager, and Grafana. This includes a prebuilt [dashboard](https://github.com/jaegertracing/jaeger/blob/master/monitoring/jaeger-mixin/dashboard-for-grafana.json). For more information, see [the documentation](https://github.com/jaegertracing/jaeger/tree/master/monitoring/jaeger-mixin). + +## Logging + +Jaeger components only log to standard out, using structured logging library [go.uber.org/zap](https://github.com/uber-go/zap) configured to write log lines as JSON encoded strings, for example: + +```json +{"level":"info","ts":1615914981.7914007,"caller":"flags/admin.go:111","msg":"Starting admin HTTP server","http-addr":":14269"} +{"level":"info","ts":1615914981.7914548,"caller":"flags/admin.go:97","msg":"Admin server started","http.host-port":"[::]:14269","health-status":"unavailable"} +``` + +The log level can be adjusted via `--log-level` command line switch; default level is `info`. + +## Traces + +Jaeger has the ability to trace some of its own components, namely the requests to the Query service. For example, if you start `all-in-one` as described in [Getting Started](../getting-started), and refresh the UI screen a few times, you will see `jaeger-all-in-one` populated in the Services dropdown. If you prefer not to see these traces in the Jaeger UI, you can disable them by running Jaeger backend components with `OTEL_TRACES_SAMPLER=always_off` environment variable, for example: + +``` +docker run -e OTEL_TRACES_SAMPLER=always_off -p 16686:16686 jaegertracing/all-in-one:{{< currentVersion >}} +``` diff --git a/content/docs/1.61/operator.md b/content/docs/1.61/operator.md new file mode 100644 index 00000000..55675134 --- /dev/null +++ b/content/docs/1.61/operator.md @@ -0,0 +1,1461 @@ +--- +title: Operator for Kubernetes +hasparent: true +--- + +# Understanding Operators + +The Jaeger Operator is an implementation of a [Kubernetes Operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/). Operators are pieces of software that ease the operational complexity of running another piece of software. More technically, _Operators_ are a method of packaging, deploying, and managing a Kubernetes application. + +A Kubernetes application is an application that is both deployed on Kubernetes and managed using the Kubernetes APIs and `kubectl` (kubernetes) or `oc` (OKD) tooling. To be able to make the most of Kubernetes, you need a set of cohesive APIs to extend in order to service and manage your apps that run on Kubernetes. Think of Operators as the runtime that manages this type of app on Kubernetes. + +# Installing the Operator + +The Jaeger Operator can be installed in Kubernetes-based clusters and is able to watch for new Jaeger custom resources (CR) in specific namespaces, or across the entire cluster. There is typically only one Jaeger Operator per cluster, but there might be at most one Jaeger Operator per namespace in multi-tenant scenarios. When a new Jaeger CR is detected, an operator will attempt to set itself as the owner of the resource, setting a label `jaegertracing.io/operated-by` to the new CR, with the operator's namespace and name as the label's value. + +{{< warning >}} +While we intend to have the Jaeger Operator working for as many Kubernetes versions as possible, it's only realistic to expect that we'll fix bugs that can be reproduced in the last three minor versions of Kubernetes (`current`, `current-1` and `current-2`). +{{< /warning >}} + +While multiple operators might coexist watching the same set of namespaces, which operator will succeed in setting itself as the owner of the CR is undefined behavior. Automatic injection of the sidecars might also result in undefined behavior. Therefore, it's highly recommended to have at most one operator watching each namespace. Note that namespaces might contain any number of Jaeger instances (CRs). + +{{< info >}} +The Jaeger Operator version tracks one version of the Jaeger components (**jaeger-query**, **jaeger-collector**, **jaeger-agent**). When a new version of the Jaeger components is released, a new version of the operator will be released that understands how running instances of the previous version can be upgraded to the new version. +{{< /info >}} + +## Prerequisite + +Since version 1.31 the Jaeger Operator uses webhooks to validate Jaeger custom resources (CRs). This requires an installed version of the [cert-manager](https://cert-manager.io/docs/). A more detailed list of supported versions can be found in the [compatibility matrix](https://github.com/jaegertracing/jaeger-operator#compatibility-matrix). An installation guide can be found [here](https://cert-manager.io/v1.6-docs/installation/#default-static-install). + +{{< warning >}} +cert-manager version 1.6.1 or higher must be installed. +{{< /warning >}} + +## Install modes + +The Jaeger Operator can be installed to watch for new Jaeger custom resources (CRs) either in the whole cluster or in specific namespaces. When configured for cluster-mode, the operator can: + +- watch for events related to Jaeger resources in all namespaces +- watch the namespaces themselves looking for the `sidecar.jaegertracing.io/inject` annotation +- watch all deployments, to inject or remove sidecars based on the `sidecar.jaegertracing.io/inject` annotation +- create cluster role bindings, when necessary + +When not using the cluster-wide resources (`ClusterRole` and `ClusterRoleBinding`), set the `WATCH_NAMESPACE` to the comma-separated list of namespaces that the Jaeger Operator should watch for events related to Jaeger resources. It is possible to have the Jaeger Operator running in a given namespace (like, `observability`) and manage Jaeger resources in another (like, `myproject`). For that, use a `RoleBinding` like the following for each namespace the operator should watch for resources: + +```yaml +kind: RoleBinding +apiVersion: rbac.authorization.k8s.io/v1 +metadata: + name: jaeger-operator-in-myproject + namespace: myproject +subjects: +- kind: ServiceAccount + name: jaeger-operator + namespace: observability +roleRef: + kind: Role + name: jaeger-operator + apiGroup: rbac.authorization.k8s.io +``` + +## Installing the Operator on Kubernetes + +The following instructions will create the `observability` namespace and install the Jaeger Operator there. By default, the operator will watch all namespaces. + +{{< info >}} +Make sure your `kubectl` command is properly configured to talk to a valid Kubernetes cluster. If you don't have a cluster, you can create one locally using [`minikube`](https://kubernetes.io/docs/tasks/tools/install-minikube/). +{{< /info >}} + +To install the operator, run: +```bash +kubectl create namespace observability # <1> +kubectl create -f https://github.com/jaegertracing/jaeger-operator/releases/download/v{{< currentVersion >}}.0/jaeger-operator.yaml -n observability # <2> +``` +<1> This creates the namespace used by default in the deployment files. If you want to install the Jaeger operator in a different namespace, you must edit the deployment files to change `observability` to the desired namespace value. + +<2> This installs the "Custom Resource Definition" for the `apiVersion: jaegertracing.io/v1` + +The operator will be installed in cluster wide mode, if you want to only watch an specific namespace you need to change the `ClusterRole` and `ClusterRoleBinding` of the operator manifest to `Role` and `RoleBinding`, also set the `WATCH_NAMESPACE` environment variable on the jaeger operator Deployment. + +At this point, there should be a `jaeger-operator` deployment available. You can view it by running the following command: + +```bash +$ kubectl get deployment jaeger-operator -n observability + +NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE +jaeger-operator 1 1 1 1 48s +``` + +The operator is now ready to create Jaeger instances. + +## Installing the Operator on OKD/OpenShift + + + +The instructions from the previous section also work for installing the operator on OKD or OpenShift. Make sure you are logged in as a privileged user, when you install the role based access control (RBAC) rules, the custom resource definition, and the operator. + +```bash +oc login -u + +oc new-project observability # <1> +oc create -f https://github.com/jaegertracing/jaeger-operator/releases/download/v{{< currentVersion >}}.0/jaeger-operator.yaml -n observability # <2> +``` +<1> This creates the namespace used by default in the deployment files. If you want to install the Jaeger operator in a different namespace, you must edit the deployment files to change `observability` to the desired namespace value. + +<2> This installs the "Custom Resource Definition" for the `apiVersion: jaegertracing.io/v1` + +The operator will be installed in cluster wide mode, if you want to only watch an specific namespace you need to change the `ClusterRole` and `ClusterRoleBinding` of the operator manifest to `Role` and `RoleBinding`, also set the `WATCH_NAMESPACE` environment variable on the jaeger operator Deployment. + +Once the operator is installed, grant the role `jaeger-operator` to users who should be able to install individual Jaeger instances. The following example creates a role binding allowing the user `developer` to create Jaeger instances: + +```bash +oc create \ + rolebinding developer-jaeger-operator \ + --role=jaeger-operator \ + --user=developer +``` + +After the role is granted, switch back to a non-privileged user. + +# Quick Start - Deploying the AllInOne image + +The simplest possible way to create a Jaeger instance is by creating a YAML file like the following example. This will install the default AllInOne strategy, which deploys the **all-in-one** image (combining **jaeger-agent**, **jaeger-collector**, **jaeger-query**, and Jaeger UI) in a single pod, using in-memory storage by default. + +{{< info >}} +This default strategy is intended for development, testing, and demo purposes, not for production. +{{< /info >}} + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: simplest +``` + +The YAML file can then be used with `kubectl`: + + +```bash +kubectl apply -f simplest.yaml +``` + +In a few seconds, a new in-memory all-in-one instance of Jaeger will be available, suitable for quick demos and development purposes. To check the instances that were created, list the `jaeger` objects: + +```bash +$ kubectl get jaegers +NAME CREATED AT +simplest 28s +``` + +To get the pod name, query for the pods belonging to the `simplest` Jaeger instance: + + +```bash +$ kubectl get pods -l app.kubernetes.io/instance=simplest +NAME READY STATUS RESTARTS AGE +simplest-6499bb6cdd-kqx75 1/1 Running 0 2m +``` + +Similarly, the logs can be queried either from the pod directly using the pod name obtained from the previous example, or from all pods belonging to our instance: + +```bash +$ kubectl logs -l app.kubernetes.io/instance=simplest +... +{"level":"info","ts":1535385688.0951214,"caller":"healthcheck/handler.go:133","msg":"Health Check state change","status":"ready"} +``` + +{{< info >}} +On OKD/OpenShift the container name must be specified. +{{< /info >}} + +```bash +$ kubectl logs -l app.kubernetes.io/instance=simplest -c jaeger +... +{"level":"info","ts":1535385688.0951214,"caller":"healthcheck/handler.go:133","msg":"Health Check state change","status":"ready"} +``` + +# Configuring the operator + +The Jaeger Operator can be configured via command-line interface parameters, via environment variables or configuration file. When the same var is specified at different levels, the precedence order is: + +1. command-line parameter (flag) +1. environment variable +1. configuration file + +Each item takes precedence over the item below it. The available options can be seen by running the operator with the `--help` flag, such as: + +```bash +$ podman run jaegertracing/jaeger-operator:master start --help +``` + +## Examples + +Setting the `log-level` parameter via flag of a given Jaeger Operator deployment (excerpt): +```yaml +apiVersion: apps/v1 +kind: Deployment +metadata: + name: jaeger-operator +spec: + template: + spec: + containers: + - name: jaeger-operator + image: jaegertracing/jaeger-operator:master + args: ["start", "--log-level=debug"] +``` + +Setting the `log-level` parameter via environment variable on a given Jaeger Operator deployment (excerpt): +```yaml +apiVersion: apps/v1 +kind: Deployment +metadata: + name: jaeger-operator +spec: + template: + spec: + containers: + - name: jaeger-operator + image: jaegertracing/jaeger-operator:master + args: ["start"] + env: + - name: LOG-LEVEL + value: debug +``` + +Setting the `log-level` parameter in the configuration file: +```yaml +log-level: debug +``` + +To use a configuration file, either create a file at `${HOME}/.jaeger-operator.yaml`, or specify the location via `--config`. + +# Deployment Strategies + +When you create a Jaeger instance, it is associated with a strategy. The strategy is defined in the custom resource file, and determines the architecture to be used for the Jaeger backend. The default strategy is `allInOne`. The other possible values are `production` and `streaming`. + +The available strategies are described in the following sections. + +## AllInOne (Default) strategy + +This strategy is intended for development, testing, and demo purposes. + +The main backend components,**jaeger-agent**, **jaeger-collector** and **jaeger-query** service, are all packaged into a single executable which is configured (by default) to use in-memory storage. This strategy cannot be scaled beyond one replica. + +## Production strategy + +The `production` strategy is intended (as the name suggests) for production environments, where long term storage of trace data is important, as well as a more scalable and highly available architecture is required. Each of the backend components is therefore separately deployed. + +**jaeger-agent** can be injected as a sidecar on the instrumented application or as a daemonset. + +**jaeger-collector** can be configured to autoscale on demand. By default, when no value for `.Spec.Collector.Replicas` is provided, the Jaeger Operator will create a Horizontal Pod Autoscaler (HPA) configuration for **jaeger-collector**. We recommend setting an explicit value for `.Spec.Collector.MaxReplicas`, along with a reasonable value for the resources that **jaeger-collector**'s pod is expected to consume. When no `.Spec.Collector.MaxReplicas` is set, the operator will set `100` as its value. Read more about HPA on [Kubernetes' website](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/). The feature can be explicitly disabled by setting `.Spec.Collector.Autoscale` to `false`. Here's an example, setting **jaeger-collector**'s limits as well as the maximum number of replicas: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: simple-prod +spec: + strategy: production + collector: + maxReplicas: 5 + resources: + limits: + cpu: 100m + memory: 128Mi +``` + +**jaeger-query** and **jaeger-collector** services are configured with a supported storage type - currently Cassandra or Elasticsearch. Multiple instances of each of these components can be provisioned as required for performance and resilience purposes. + +The main additional requirement is to provide the details of the storage type and options, for example: + +```yaml + storage: + type: elasticsearch + options: + es: + server-urls: http://elasticsearch:9200 +``` + +## Streaming strategy + +The `streaming` strategy is designed to augment the `production` strategy by providing a streaming capability that effectively sits between the collector and the backend storage (Cassandra or Elasticsearch). This provides the benefit of reducing the pressure on the backend storage, under high load situations, and enables other trace post-processing capabilities to tap into the real time span data directly from the streaming platform (Kafka). + +**jaeger-collector** can be configured to autoscale on demand, as described in the "Production strategy" section. + +**jaeger-ingester** can also be configured to autoscale on demand. By default, when no value for `.Spec.Ingester.Replicas` is provided, the Jaeger Operator will create a Horizontal Pod Autoscaler (HPA) configuration for **jaeger-ingester**. We recommend setting an explicit value for `.Spec.Ingester.MaxReplicas`, along with a reasonable value for the resources that **jaeger-ingester**'s pod is expected to consume. When no `.Spec.Ingester.MaxReplicas` is set, the operator will set `100` as its value. Read more about HPA on [Kubernetes' website](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/). The feature can be explicitly disabled by setting `.Spec.Ingester.Autoscale` to `false`. Here's an example, setting **jaeger-ingester**'s limits as well as the maximum number of replicas: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: simple-streaming +spec: + strategy: streaming + ingester: + maxReplicas: 8 + resources: + limits: + cpu: 100m + memory: 128Mi +``` + +{{< info >}} +A Kafka environment can be configured using [Strimzi's Kafka operator](https://strimzi.io/). +{{< /info >}} + +#### Existing Kafka Cluster + +The only additional information required is to provide the details for accessing the Kafka platform, which is configured in the `collector` component (as producer) and `ingester` component (as consumer): + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: simple-streaming +spec: + strategy: streaming + collector: + options: + kafka: # <1> + producer: + topic: jaeger-spans + brokers: my-cluster-kafka-brokers.kafka:9092 + ingester: + options: + kafka: # <1> + consumer: + topic: jaeger-spans + brokers: my-cluster-kafka-brokers.kafka:9092 + ingester: + deadlockInterval: 5s # <2> + storage: + type: elasticsearch + options: + es: + server-urls: http://elasticsearch:9200 +``` +<1> Identifies the Kafka configuration used by **jaeger-collector** to produce the messages, and by **jaeger-ingester** to consume them. + +<2> The deadlock interval is disabled by default (set to 0), to prevent **jaeger-ingester** from being terminated when no messages arrive. It can be configured to specify the number of minutes to wait for a message before terminating. + +#### Self Provisioned Kafka Cluster + +To use the self-provisioned approach, the producer/consumer brokers property should not be defined. + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: auto-provision-kafka +spec: + strategy: streaming + storage: + type: elasticsearch + options: + es: + # Note: This assumes elasticsearch is running in the "default" namespace. + server-urls: http://elasticsearch.default.svc:9200 +``` + +The self-provision of a Kafka cluster can be disabled by setting the flag `--kafka-provision` to `false`. The default value is `auto`, which will make the Jaeger Operator query the Kubernetes cluster for its ability to handle a `Kafka` custom resource. This is usually set by the Kafka Operator during its installation process, so, if the Kafka Operator is expected to run *after* the Jaeger Operator, the flag can be set to `true`. + +# Understanding Custom Resource Definitions + +In the Kubernetes API, a resource is an endpoint that stores a collection of API objects of a certain kind. For example, the built-in Pods resource contains a collection of Pod objects. A _Custom Resource Definition_ (CRD) object defines a new, unique object `Kind` in the cluster and lets the Kubernetes API server handle its entire lifecycle. + +To create _Custom Resource_ (CR) objects, cluster administrators must first create a Custom Resource Definition (CRD). The CRDs allow cluster users to create CRs to add the new resource types into their projects. An Operator watches for custom resource objects to be created, and when it sees a custom resource being created, it creates the application based on the parameters defined in the custom resource object. + +{{< info >}} +While only cluster administrators can create CRDs, developers can create the CR from an existing CRD if they have read and write permission to it. +{{< /info >}} + + + +For reference, here's how you can create a more complex all-in-one instance: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: my-jaeger +spec: + strategy: allInOne # <1> + allInOne: + image: jaegertracing/all-in-one:latest # <2> + options: # <3> + log-level: debug # <4> + storage: + type: memory # <5> + options: # <6> + memory: # <7> + max-traces: 100000 + ingress: + enabled: false # <8> + agent: + strategy: DaemonSet # <9> + annotations: + scheduler.alpha.kubernetes.io/critical-pod: "" # <10> +``` + +<1> The default strategy is `allInOne`. The other possible values are `production` and `streaming`. + +<2> The image to use, in a regular Docker syntax. + +<3> The (non-storage related) options to be passed verbatim to the underlying binary. Refer to the Jaeger documentation and/or to the `--help` option from the related binary for all the available options. + +<4> The option is a simple `key: value` map. In this case, we want the option `--log-level=debug` to be passed to the binary. + +<5> The storage type to be used. By default it will be `memory`, but can be any other supported storage type (Cassandra, Elasticsearch, Kafka). + +<6> All storage related options should be placed here, rather than under the 'allInOne' or other component options. + +<7> Some options are namespaced and we can alternatively break them into nested objects. We could have specified `memory.max-traces: 100000`. + +<8> By default, an ingress object is created for the **jaeger-query** service. It can be disabled by setting its `enabled` option to `false`. If deploying on OpenShift, this will be represented by a Route object. + +<9> By default, the operator assumes that **jaeger-agent**s are deployed as sidecars within the target pods. Specifying the strategy as "DaemonSet" changes that and makes the operator deploy **jaeger-agent** as DaemonSet. Note that your tracer client will probably have to override the "JAEGER_AGENT_HOST" environment variable to use the node's IP. + +<10> Define annotations to be applied to all deployments (not services). These can be overridden by annotations defined on the individual components. + +You can view example custom resources for different Jaeger configurations [on GitHub](https://github.com/jaegertracing/jaeger-operator/tree/main/examples). + +# Configuring the Custom Resource + + + +You can use the simplest example (shown above) and create a Jaeger instance using the defaults, or you can create your own custom resource file. + +## Span storage options + +### Cassandra storage + +When the storage type is set to Cassandra, the operator will automatically create a batch job that creates the required schema for Jaeger to run. This batch job will block the Jaeger installation, so that it starts only after the schema is successfully created. The creation of this batch job can be disabled by setting the `enabled` property to `false`: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: cassandra-without-create-schema +spec: + strategy: allInOne + storage: + type: cassandra + cassandraCreateSchema: + enabled: false # <1> +``` +<1> Defaults to `true` + +Further aspects of the batch job can be configured as well. An example with all the possible options is shown below: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: cassandra-with-create-schema +spec: + strategy: allInOne # <1> + storage: + type: cassandra + options: # <2> + cassandra: + servers: cassandra + keyspace: jaeger_v1_datacenter3 + cassandraCreateSchema: # <3> + datacenter: "datacenter3" + mode: "test" +``` +<1> The same works for `production` and `streaming`. + +<2> These options are for the regular Jaeger components, like `collector` and `query`. + +<3> The options for the `create-schema` job. + +{{< info >}} +The default create-schema job uses `MODE=prod`, which implies a replication factor of `2`, using `NetworkTopologyStrategy` as the class, effectively meaning that at least 3 nodes are required in the Cassandra cluster. If a `SimpleStrategy` is desired, set the mode to `test`, which then sets the replication factor of `1`. Refer to the [create-schema script](https://github.com/jaegertracing/jaeger/blob/main/plugin/storage/cassandra/schema/create.sh) for more details. +{{< /info >}} + +### Elasticsearch storage + +By default Elasticsearch storage does not require any initialization job to be run. However Elasticsearch +storage requires a cron job to be run to clean old data from the storage. + +When rollover (`es.use-aliases`) is enabled, Jaeger operator also deploys a job to initialize Elasticsearch storage +and another two cron jobs to perform required index management actions. + +#### External Elasticsearch + +Jaeger can be used with an external Elasticsearch cluster. +The following example shows a Jaeger CR using an external Elasticsearch cluster (created +by [Elasticsearch Operator](https://operatorhub.io/operator/elastic-cloud-eck)) +with TLS CA certificate mounted from a volume and user/password stored in a secret. + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: simple-prod +spec: + strategy: production + storage: + type: elasticsearch # <1> + options: + es: + server-urls: https://quickstart-es-http.default.svc:9200 # <2> + index-prefix: my-prefix + tls: # <3> + ca: /es/certificates/ca.crt + secretName: jaeger-secret # <4> + volumeMounts: # <5> + - name: certificates + mountPath: /es/certificates/ + readOnly: true + volumes: + - name: certificates + secret: + secretName: quickstart-es-http-certs-public +``` + +<1> Storage type Elasticsearch. + +<2> Url to Elasticsearch service running in default namespace. + +<3> TLS configuration. In this case only CA certificate, but it can also contain `es.tls.key` and `es.tls.cert` when using mutual TLS. + +<4> Secret which defines environment variables `ES_PASSWORD` and `ES_USERNAME`. Created by `kubectl create secret generic jaeger-secret --from-literal=ES_PASSWORD=changeme --from-literal=ES_USERNAME=elastic` + +<5> Volume mounts and volumes which are mounted into all storage components. + +#### Self provisioned + +Under some circumstances, the Jaeger Operator can make use of the [Elasticsearch Operator](https://github.com/openshift/elasticsearch-operator) to provision a suitable Elasticsearch cluster. Jaeger CR exposes the same configuration as [OpenShift Cluster Logging](https://docs.openshift.com/container-platform/4.2/logging/config/cluster-logging-elasticsearch.html). + +{{< warning >}} +This feature is supported only on OKD/OpenShift clusters. Spark dependencies are not supported with this feature [Issue #294](https://github.com/jaegertracing/jaeger-operator/issues/294). +{{< /warning >}} + +When there is no `es.server-urls` option as part of a Jaeger `production` instance and `elasticsearch` is set as the storage type, the Jaeger Operator creates an Elasticsearch cluster via the Elasticsearch Operator by creating a Custom Resource based on the configuration provided in storage section. The Elasticsearch cluster is meant to be dedicated for a single Jaeger instance. + +Follows an example of Jaeger with a single node Elasticsearch cluster with AWS `gp2` persistent storage: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: simple-prod +spec: + strategy: production + storage: + type: elasticsearch + elasticsearch: + nodeCount: 1 # <1> + storage: # <2> + storageClassName: gp2 + size: 5Gi + resources: # <3> + requests: + cpu: 200m + memory: 4Gi + limits: + memory: 4Gi + redundancyPolicy: ZeroRedundancy # <4> +``` +<1> Number of Elasticsearch nodes. For high availability use at least 3 nodes. Do not use 2 nodes as "split brain" problem can happen. + +<2> Persistent storage configuration. In this case AWS `gp2` with `5Gi` size. When omitted `emptyDir` is used. Elasticsearch operator provisions `PersistentVolumeClaim` and `PersistentVolume` which are not removed with Jaeger instance. The same volumes can be mounted if Jaeger with the same name and namespace is crated. Some storages might fail in `default` namespace because of OpenShift SCC policy. + +<3> Resources for Elasticsearch nodes. In this case `4Gi` which results to by default required `2Gi` of heap space. Refer to Elasticsearch [documentation](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/heap-size.html) for memory recommendations. + +<4> Data replication policy defines how Elasticsearch shards are replicated across data nodes in the cluster. If not specified Jaeger Operator automatically determines the most appropriate replication based on number of nodes. + +* `FullRedundancy` Elasticsearch fully replicates the primary shards for each index to every data node. This provides the highest safety, but at the cost of the highest amount of disk required and the poorest performance. +* `MultipleRedundancy` Elasticsearch fully replicates the primary shards for each index to half of the data nodes. This provides a good tradeoff between safety and performance. +* `SingleRedundancy` Elasticsearch makes one copy of the primary shards for each index. Data are always available and recoverable as long as at least two data nodes exist. Better performance than MultipleRedundancy, when using 5 or more nodes. You cannot apply this policy on deployments of single Elasticsearch node. +* `ZeroRedundancy` Elasticsearch does not make copies of the primary shards. Data might be unavailable or lost in the event a node is down or fails. Use this mode when you are more concerned with performance than safety, or have implemented your own disk/PVC backup/restore strategy. + +The self-provision of an Elasticsearch cluster can be disabled by setting the flag `--es-provision` to `false`. The default value is `auto`, which will make the Jaeger Operator query the Kubernetes cluster for its ability to handle a `Elasticsearch` custom resource. This is usually set by the Elasticsearch Operator during its installation process, so, if the Elasticsearch Operator is expected to run *after* the Jaeger Operator, the flag can be set to `true`. + +{{< danger >}} +At the moment there can be only one Jaeger with self-provisioned Elasticsearch instance per namespace. +{{< /danger >}} + +#### Elasticsearch index cleaner job + +When using `elasticsearch` storage by default a cron job is created to clean old traces from it, the options for it are listed below so you can configure it to your use case. +The connection configuration is derived from the storage options. + +```yaml +storage: + type: elasticsearch + esIndexCleaner: + enabled: true // turn the cron job deployment on and off + numberOfDays: 7 // number of days to wait before deleting a record + schedule: "55 23 * * *" // cron expression for it to run +``` + +The connection configuration to storage is derived from storage options. + +#### Elasticsearch rollover + +This index management strategy is more complicated than using the default daily indices and +it requires an initialization job to prepare the storage and two cron jobs to manage indices. +The first cron job is used for rolling-over to a new index and the second for removing +indices from read alias. The rollover feature is used when storage option `es.use-aliases` is enabled. + +To learn more about rollover index management in Jaeger refer to this +[article](https://medium.com/jaegertracing/using-elasticsearch-rollover-to-manage-indices-8b3d0c77915d). + +```yaml +storage: + type: elasticsearch + options: + es: + use-aliases: true + esRollover: + conditions: "{\"max_age\": \"2d\"}" // conditions when to rollover to a new index + readTTL: 168h // how long should be old data available for reading (7 days) + schedule: "55 23 * * *" // cron expression for it to run +``` + +The connection configuration to storage is derived from storage options. + +##### Elasticsearch index lifecycle management + +[Index lifecycle management](https://www.elastic.co/guide/en/elasticsearch/reference/current/index-lifecycle-management.html) +(ILM) is an Elasticsearch feature from X-Pack plugin that +manages lifecycle of indices. In the context of the Operator it means that +ILM can be used instead of rollover cron jobs. +The Jaeger project does not provide a direct integration with the ILM, +however the Jaeger instance can be configured to use index aliases (required by ILM) +and disable index template creation and rollover cron jobs. +This allows users to configure ILM in custom index templates before Jaeger is deployed. + +```yaml +spec: + strategy: production + collector: + options: + es: + use-aliases: true # <1> + query: + options: + es: + use-aliases: true # <1> + storage: + type: elasticsearch + options: + es: + create-index-templates: false # <2> + server-urls: http://elasticsearch:9200 +``` + +<1> Configures **jaeger-query** and **jaeger-collector** to use read and write index aliases. + +<2> Disables creation of default index templates. + +### Storage plugin + +{{< warning >}} +Sidecar plugins will not be supported from v1.58. Custom storage backends should migrate to Remote Storage API. +{{< /warning >}} + +## Metrics storage options + +### Prometheus + +Setting `spec.metricsStorage.type` to `prometheus` enables using Jaeger with +PromQL-compatible storage implementations to **jaeger-query** R.E.D metrics for the +[Service Performance Monitoring](../spm) feature. + +The following is an example of a Jaeger CR using the `allInOne` deployment strategy, +an in-memory span storage and prometheus metrics storage. + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: jaeger-spm +spec: + strategy: allInOne + allInOne: + image: jaegertracing/all-in-one:latest + options: + log-level: debug + query: + base-path: /jaeger + prometheus: # <1> + server-url: "http://prometheus:9090" # <2> + metricsStorage: # <3> + type: prometheus # <4> + storage: + options: + memory: + max-traces: 100000 +``` + +<1> Beginning of `prometheus`-namespaced configuration, defined as a simple `key: value` map. + All available options are documented in the + [Jaeger All-In-One with Prometheus CLI section](../cli#jaeger-all-in-one-prometheus) + +<2> Overrides the default `http://localhost:9090` prometheus server URL with `http://prometheus:9090`. + +<3> Section to enable metrics querying capabilities. + +<4> Selects `prometheus` as the metrics storage backend. + + +## Deriving dependencies + +The processing to derive dependencies will collect spans from storage, analyzes links between services and store them for later presentation in the UI. +This job can only be used with the `production` strategy and storage type `cassandra` or `elasticsearch`. + +```yaml +storage: + type: elasticsearch + dependencies: + enabled: true # turn the job deployment on and off + schedule: "55 23 * * *" # cron expression for it to run + sparkMaster: # spark master connection string, when empty spark runs in embedded local mode + resources: + requests: + memory: 4096Mi + limits: + memory: 4096Mi + +``` + +The connection configuration to storage is derived from storage options. + +{{< warning >}} +Make sure to assign enough memory resources. Spark [documentation](https://spark.apache.org/docs/2.4.4/hardware-provisioning.html#memory) recommends at least `8Gi` of memory. +However the job is able to starts with at least `2Gi` of memory. The right memory settings +will depend on the amount of data being processed. +Note that the job loads all data for the current day into memory. +{{< /warning >}} + +## Auto-injecting Jaeger Agent Sidecars + +{{< warning >}} +Currently, only `Deployments` are supported for auto-injecting **jaeger-agent** sidecars. + +For other controller types, please see [Manually Defining Jaeger Agent Sidecars](#manually-defining-jaeger-agent-sidecars) below. + +Support for auto-injecting other controller types is being tracked with [Issue #750](https://github.com/jaegertracing/jaeger-operator/issues/750). +{{< /warning >}} + +The operator can inject **jaeger-agent** sidecars in `Deployment` workloads, provided that the deployment or its namespace has the annotation `sidecar.jaegertracing.io/inject` with a suitable value. The values can be either `"true"` (as string), or the Jaeger instance name, as returned by `kubectl get jaegers`. When `"true"` is used, there should be exactly *one* Jaeger instance for the same namespace as the deployment, otherwise, the operator can't figure out automatically which Jaeger instance to use. A specific Jaeger instance name on a deployment has a higher precedence than `true` applied on its namespace. + +The following snippet shows a simple application that will get a sidecar injected, with **jaeger-agent** pointing to the single Jaeger instance available in the same namespace: + +```yaml +apiVersion: apps/v1 +kind: Deployment +metadata: + name: myapp + annotations: + "sidecar.jaegertracing.io/inject": "true" # <1> +spec: + selector: + matchLabels: + app: myapp + template: + metadata: + labels: + app: myapp + spec: + containers: + - name: myapp + image: acme/myapp:myversion +``` +<1> Either `"true"` (as string) or the Jaeger instance name. + +A complete sample deployment is available at [`deploy/examples/business-application-injected-sidecar.yaml`](https://github.com/jaegertracing/jaeger-operator/blob/main/examples/business-application-injected-sidecar.yaml). + +When the sidecar is injected, **jaeger-agent** can then be accessed at its default location on `localhost`. + +### Deployment-level Configurations for Injected Sidecars + +Since the sidecar may be injected in Deployments that are not managed by the jaeger-operator, many configurations that apply at the Deployment-level are not applied to a sidecar's Deployment *unless* they are specified under **jaeger-agent** node. The following configurations are supported for the sidecar's Deployment: + +- Volumes (& VolumeMounts) +- ImagePullSecrets + +E.g. the following Jaeger configuration will add the `agent-volume` and `agent-imagePullSecrets` to the sidecar's deployment. + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: my-jaeger +spec: + agent: + volumeMounts: + - name: agent-volume + mountPath: /tmp/agent + readOnly: true + volumes: + - name: agent-volume + secret: + secretName: agent-secret + imagePullSecrets: + - name: agent-imagePullSecret +``` + +## Manually Defining Jaeger Agent Sidecars + +For controller types other than `Deployments` (e.g. `StatefulSets`, `DaemonSets`, etc), **jaeger-agent** sidecar can be manually defined in your specification. + +The following snippet shows the manual definition you can include in your `containers` section for a **jaeger-agent** sidecar: + +```yaml +- name: jaeger-agent + image: jaegertracing/jaeger-agent:latest + imagePullPolicy: IfNotPresent + ports: + - containerPort: 5775 + name: zk-compact-trft + protocol: UDP + - containerPort: 5778 + name: config-rest + protocol: TCP + - containerPort: 6831 + name: jg-compact-trft + protocol: UDP + - containerPort: 6832 + name: jg-binary-trft + protocol: UDP + - containerPort: 14271 + name: admin-http + protocol: TCP + args: + - --reporter.grpc.host-port=dns:///jaeger-collector-headless.observability:14250 + - --reporter.type=grpc +``` + +A complete sample `StatefulSet` is available at [`deploy/examples/statefulset-manual-sidecar.yaml`](https://github.com/jaegertracing/jaeger-operator/tree/main/examples/statefulset-manual-sidecar.yaml). + +**jaeger-agent** can then be accessed at its default location on `localhost`. + +## Installing the Agent as DaemonSet + +By default, the Operator expects **jaeger-agent**s to be deployed as sidecars to the target applications. This is convenient for several purposes, like in a multi-tenant scenario or to have better load balancing, but there are scenarios where you might want to install **jaeger-agent** as a `DaemonSet`. In that case, specify the **jaeger-agent**'s strategy to `DaemonSet`, as follows: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: my-jaeger +spec: + agent: + strategy: DaemonSet +``` + +{{< danger >}} +If you attempt to install two Jaeger instances on the same cluster with `DaemonSet` as the strategy, only *one* will end up deploying a `DaemonSet`, as the agent is required to bind to well-known ports on the node. Because of that, the second daemon set will fail to bind to those ports. +{{< /danger >}} + +Your tracer client will then most likely need to be told where **jaeger-agent** is located. This is usually done by setting the environment variable `JAEGER_AGENT_HOST` to the value of the Kubernetes node's IP, for example: + +```yaml +apiVersion: apps/v1 +kind: Deployment +metadata: + name: myapp +spec: + selector: + matchLabels: + app: myapp + template: + metadata: + labels: + app: myapp + spec: + containers: + - name: myapp + image: acme/myapp:myversion + env: + - name: JAEGER_AGENT_HOST + valueFrom: + fieldRef: + fieldPath: status.hostIP +``` + +### OpenShift + +In OpenShift, a `HostPort` can only be set when a special security context is set. A separate service account can be used by **jaeger-agent** with the permission to bind to `HostPort`, as follows: + +```bash +oc create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/main/examples/openshift/hostport-scc-daemonset.yaml # <1> +oc new-project myproject +oc create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/main/examples/openshift/service_account_jaeger-agent-daemonset.yaml # <2> +oc adm policy add-scc-to-user daemonset-with-hostport -z jaeger-agent-daemonset # <3> +oc apply -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/main/examples/openshift/agent-as-daemonset.yaml # <4> +``` +<1> The `SecurityContextConstraints` with the `allowHostPorts` policy + +<2> The `ServiceAccount` to be used by **jaeger-agent** + +<3> Adds the security policy to the service account + +<4> Creates the Jaeger Instance using the `serviceAccount` created in the steps above + +{{< warning >}} +Without such a policy, errors like the following will prevent a `DaemonSet` to be created: `Warning FailedCreate 4s (x14 over 45s) daemonset-controller Error creating: pods "agent-as-daemonset-agent-daemonset-" is forbidden: unable to validate against any security context constraint: [spec.containers[0].securityContext.containers[0].hostPort: Invalid value: 5775: Host ports are not allowed to be used` +{{< /warning >}} + +After a few seconds, the `DaemonSet` should be up and running: + +```bash +$ oc get daemonset agent-as-daemonset-agent-daemonset +NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE +agent-as-daemonset-agent-daemonset 1 1 1 1 1 +``` + +### Calico CNI + +In AWS EKS (or Fargate) running custom Calico CNI webhooks pointing at service cannot be reached. + +Below error is displayed when `jaeger` resource is requested. + +```bash +Error from server (InternalError): Internal error occurred: failed calling webhook "myservice.mynamespace.svc": Post "https://myservice.mynamespace.svc:443/mutate?timeout=30s": Address is not allowed +``` + +In order to workaround that issue: + +- set `hostNetwork:true` on `jaeger-operator` deployment +- change `/healtz` and `/readyz` ports from 8081 to other value +- change `kube-rbac-proxy` secure port from 8443 to other value +- change `webhook-server` port from 9443 to other value + - this setting is controlled by `webhook-bind-port` flag + +Jaeger operator config example: + +```yaml +--- +apiVersion: v1 +kind: Service +metadata: + labels: + app.kubernetes.io/name: jaeger-operator + name: jaeger-operator + name: jaeger-operator-webhook-service + namespace: monitoring +spec: + ports: + - port: 443 + protocol: TCP + targetPort: 10290 + selector: + app.kubernetes.io/name: jaeger-operator + name: jaeger-operator +--- +... + spec: + hostNetwork: true + containers: + - args: + - start + - --health-probe-bind-address=:10280 + - --webhook-bind-port=10290 + - --leader-elect + command: + - /jaeger-operator + ... + ports: + - containerPort: 10290 + name: webhook-server + protocol: TCP + ... + readinessProbe: + httpGet: + path: /readyz + port: 10280 + ... + livenessProbe: + httpGet: + path: /healthz + port: 10280 +``` + +Kube-rbac-proxy config example: + +```yaml +--- +apiVersion: v1 +kind: Service +metadata: + labels: + app.kubernetes.io/component: metrics + app.kubernetes.io/name: jaeger-operator + name: jaeger-operator + name: jaeger-operator-metrics + namespace: monitoring +spec: + ports: + - name: https + port: 10270 + protocol: TCP + targetPort: https + selector: + app.kubernetes.io/name: jaeger-operator + name: jaeger-operator +--- +... + spec: + hostNetwork: true + containers: + - args: + - --secure-listen-address=0.0.0.0:10270 + - --upstream=http://127.0.0.1:8383/ + - --logtostderr=true + - --v=0 + ... + ports: + - containerPort: 10270 + name: https + protocol: TCP +``` + +{{< warning >}} +Above port values must be globally unique, so `jaeger-operator` port can expose it on every k8s node. +{{< /warning >}} + +## Secrets Support + +The Operator supports passing secrets to the **jaeger-collector**, **jaeger-query** and **all-in-one** deployments. This can be used for example, to pass credentials (username/password) to access the underlying storage backend (for example: Elasticsearch). +The secrets are available as environment variables in the (Collector/Query/All-In-One) nodes. + +```yaml + storage: + type: elasticsearch + options: + es: + server-urls: http://elasticsearch:9200 + secretName: jaeger-secrets +``` + +The secret itself would be managed outside of the `jaeger-operator` custom resource. + +## Configuring the UI + +Information on various configuration options for the UI can be found [here](../frontend-ui/#configuration), defined in json format. + +To apply UI configuration changes within the Custom Resource, the same information can be included in yaml format as shown below: + +```yaml + ui: + options: + dependencies: + menuEnabled: false + tracking: + gaID: UA-000000-2 + menu: + - label: "About Jaeger" + items: + - label: "Documentation" + url: "https://www.jaegertracing.io/docs/latest" + linkPatterns: + - type: "logs" + key: "customer_id" + url: /search?limit=20&lookback=1h&service=frontend&tags=%7B%22customer_id%22%3A%22#{customer_id}%22%7D + text: "Search for other traces for customer_id=#{customer_id}" +``` + +## Defining Sampling Strategies + +{{< info >}} +This is not relevant if a trace was started by the Istio proxy as the sampling decision is made there. And the Jaeger sampling decisions are only relevant when you are using the Jaeger tracer (client). +{{< /info >}} + +The operator can be used to define sampling strategies that will be supplied to tracers that have been configured to use a remote sampler: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: with-sampling +spec: + strategy: allInOne + sampling: + options: + default_strategy: + type: probabilistic + param: 0.5 +``` + +This example defines a default sampling strategy that is probabilistic, with a 50% chance of the trace instances being sampled. + +Refer to the Jaeger documentation on [Collector Sampling Configuration](https://www.jaegertracing.io/docs/latest/sampling/#collector-sampling-configuration) to see how service and endpoint sampling can be configured. The JSON representation described in that documentation can be used in the operator by converting to YAML. + +## Finer grained configuration + +The custom resource can be used to define finer grained Kubernetes configuration applied to all Jaeger components or at the individual component level. + +When a common definition (for all Jaeger components) is required, it is defined under the `spec` node. When the definition relates to an individual component, it is placed under the `spec/` node. + +The types of supported configuration include: + +* [affinity](https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#affinity-and-anti-affinity) to determine which nodes a pod can be allocated to + +* [annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/) + +* [labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/) + +* [resources](https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container) to limit cpu and memory + +* [tolerations](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/) in conjunction with `taints` to enable pods to avoid being repelled from a node + +* [volumes](https://kubernetes.io/docs/concepts/storage/volumes/) and volume mounts + +* [serviceAccount](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/) to run each component with separate identity + +* [securityContext](https://kubernetes.io/docs/tasks/configure-pod-container/security-context/) to define privileges of running components + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: simple-prod +spec: + strategy: production + storage: + type: elasticsearch + options: + es: + server-urls: http://elasticsearch:9200 + annotations: + key1: value1 + labels: + key2: value2 + resources: + requests: + memory: "64Mi" + cpu: "250m" + limits: + memory: "128Mi" + cpu: "500m" + affinity: + nodeAffinity: + requiredDuringSchedulingIgnoredDuringExecution: + nodeSelectorTerms: + - matchExpressions: + - key: kubernetes.io/e2e-az-name + operator: In + values: + - e2e-az1 + - e2e-az2 + preferredDuringSchedulingIgnoredDuringExecution: + - weight: 1 + preference: + matchExpressions: + - key: another-node-label-key + operator: In + values: + - another-node-label-value + tolerations: + - key: "key1" + operator: "Equal" + value: "value1" + effect: "NoSchedule" + - key: "key1" + operator: "Equal" + value: "value1" + effect: "NoExecute" + serviceAccount: nameOfServiceAccount + securityContext: + runAsUser: 1000 + volumeMounts: + - name: config-vol + mountPath: /etc/config + volumes: + - name: config-vol + configMap: + name: log-config + items: + - key: log_level + path: log_level +``` + +Note: If necessary, imagePullSecrets can be configured for components through their serviceAccounts (see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#add-image-pull-secret-to-service-account). For the sidecar, see the [Deployment-level Configurations for Injected Sidecars](#deployment-level-configurations-for-injected-sidecars) section. + +# Accessing the Jaeger Console (UI) + + +## Kubernetes + +The operator creates a Kubernetes [`ingress`](https://kubernetes.io/docs/concepts/services-networking/ingress/) route, which is the Kubernetes' standard for exposing a service to the outside world, but by default it does not come with Ingress providers. +Check the [Kubernetes documentation](https://kubernetes.github.io/ingress-nginx/deploy/#verify-installation) for the most appropriate way to achieve an Ingress provider for your platform. The following command enables the Ingress provider on `minikube`: + +```bash +minikube addons enable ingress +``` + +Once Ingress is enabled, the address for the Jaeger console can be found by querying the Ingress object: + +```bash +$ kubectl get ingress +NAME HOSTS ADDRESS PORTS AGE +simplest-query * 192.168.122.34 80 3m +``` + +In this example, the Jaeger UI is available at http://192.168.122.34. + +To enable TLS in the Ingress, pass a `secretName` with the name of a [Secret](https://kubernetes.io/docs/concepts/configuration/secret/) containing the TLS certificate: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: ingress-with-tls +spec: + ingress: + secretName: my-tls-secret +``` + +## OpenShift + +When the Operator is running on OpenShift, the Operator will automatically create a `Route` object for the query services. Use the following command to check the hostname/port: + +```bash +oc get routes +``` + +{{< info >}} +Make sure to use `https` with the hostname/port you get from the command above, otherwise you'll see a message like: "Application is not available". +{{< /info >}} + +By default, the Jaeger UI is protected with OpenShift's OAuth service and any valid user is able to login. To disable this feature and leave the Jaeger UI unsecured, set the Ingress property `security` to `none` in the custom resource file: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: disable-oauth-proxy +spec: + ingress: + security: none +``` + +Custom `SAR` and `Delegate URL` values can be specified as part of the `.Spec.Ingress.OpenShift.SAR` and `.Spec.Ingress.Openshift.DelegateURLs`, as follows: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: custom-sar-oauth-proxy +spec: + ingress: + openshift: + sar: '{"namespace": "default", "resource": "pods", "verb": "get"}' + delegateUrls: '{"/":{"namespace": "default", "resource": "pods", "verb": "get"}}' +``` + +When the `delegateUrls` is set, the Jaeger Operator needs to create a new `ClusterRoleBinding` between the service account used by the UI Proxy (`{InstanceName}-ui-proxy`) and the role `system:auth-delegator`, as required by the OpenShift OAuth Proxy. Because of that, the service account used by the operator itself needs to have the same cluster role binding. To accomplish that, a `ClusterRoleBinding` such as the following has to be created: + +```yaml +kind: ClusterRoleBinding +apiVersion: rbac.authorization.k8s.io/v1 +metadata: + name: jaeger-operator-with-auth-delegator + namespace: observability +subjects: +- kind: ServiceAccount + name: jaeger-operator + namespace: observability +roleRef: + kind: ClusterRole + name: system:auth-delegator + apiGroup: rbac.authorization.k8s.io +``` + +Cluster administrators not comfortable in letting users deploy Jaeger instances with this cluster role are free to not add this cluster role to the operator's service account. In that case, the Operator will auto-detect that the required permissions are missing and will log a message similar to: `the requested instance specifies the delegateUrls option for the OAuth Proxy, but this operator cannot assign the proper cluster role to it (system:auth-delegator). Create a cluster role binding between the operator's service account and the cluster role 'system:auth-delegator' in order to allow instances to use 'delegateUrls'`. + +The Jaeger Operator also supports authentication using `htpasswd` files via the OpenShift OAuth Proxy. To make use of that, specify the `htpasswdFile` option within the OpenShift-specific entries, pointing to the file `htpasswd` file location in the local disk. The `htpasswd` file can be created using the `htpasswd` utility: + +```console +$ htpasswd -cs /tmp/htpasswd jdoe +New password: +Re-type new password: +Adding password for user jdoe +``` + +This file can then be used as the input for the `kubectl create secret` command: + +```console +$ kubectl create secret generic htpasswd --from-file=htpasswd=/tmp/htpasswd +secret/htpasswd created +``` + +Once the secret is created, it can be specified in the Jaeger CR as a volume/volume mount: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: with-htpasswd +spec: + ingress: + openshift: + sar: '{"namespace": "default", "resource": "pods", "verb": "get"}' + htpasswdFile: /usr/local/data/htpasswd + volumeMounts: + - name: htpasswd-volume + mountPath: /usr/local/data + volumes: + - name: htpasswd-volume + secret: + secretName: htpasswd +``` + +# Upgrading the Operator and its managed instances + +Each version of the Jaeger Operator follows one Jaeger version. Whenever a new version of the Jaeger Operator is installed, all the Jaeger instances managed by the operator will be upgraded to the Operator's supported version. For example, an instance named `simplest` that was created with Jaeger Operator 1.12.0 will be running Jaeger 1.12.0. Once the Jaeger Operator is upgraded to 1.13.0, the instance `simplest` will be upgraded to the version 1.13.0, following the official upgrade instructions from the Jaeger project. + +The Jaeger Operator can be upgraded manually by changing the deployment (`kubectl edit deployment jaeger-operator`), or via specialized tools such as the [Operator Lifecycle Manager (OLM)](https://github.com/operator-framework/operator-lifecycle-manager). + +# Updating a Jaeger instance (experimental) + +A Jaeger instance can be updated by changing the `CustomResource`, either via `kubectl edit jaeger simplest`, where `simplest` is the Jaeger's instance name, or by applying the updated YAML file via `kubectl apply -f simplest.yaml`. + +{{< danger >}} +The name of the Jaeger instance cannot be updated, as it is part of the identifying information for the resource. +{{< /danger >}} + +Simpler changes such as changing the replica sizes can be applied without much concern, whereas changes to the strategy should be watched closely and might potentially cause an outage for individual components (collector/query/agent). + +While changing the backing storage is supported, migration of the data is not. + +# Removing a Jaeger instance + + +To remove an instance, use the `delete` command with the custom resource file used when you created the instance: + +```bash +kubectl delete -f simplest.yaml +``` + +Alternatively, you can remove a Jaeger instance by running: + +```bash +kubectl delete jaeger simplest +``` + +{{< info >}} +Deleting the instance will not remove the data from any permanent storage used with this instance. Data from in-memory instances, however, will be lost. +{{< /info >}} + +# Tracing and debugging the operator + +Starting from version 1.16.0, the Jaeger Operator is able to generate spans related to its own operations. To take advantage of that, the `operator.yaml` has to be configured to enable tracing by setting the flag `--tracing-enabled=true` to the `args` of the container and to add a Jaeger Agent as sidecar to the pod. Here's an excerpt from an `operator.yaml` that has tracing enabled and assumes that the Jaeger instance is at the same namespace as the Jaeger Operator: + +```yaml +... + # .Spec.Template.Spec.Containers[0].Args + args: ["start", "--tracing-enabled=true"] +... + # add as a second container to .Spec.Template.Spec.Containers + - name: jaeger-agent + image: jaegertracing/jaeger-agent:latest # it's best to keep this version in sync with the operator's + env: + - name: POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + args: + - --reporter.grpc.host-port=dns:///jaeger-collector-headless.$(POD_NAMESPACE).svc.cluster.local:14250 + ports: + - containerPort: 6831 + name: jg-compact-trft + protocol: UDP +``` + +Note that you must also manually provision the Jaeger instance. You can do this after the Jaeger Operator has been initialized. **jaeger-agent** will keep the Operator spans in the internal buffer until it makes a connection to the Jaeger instance. The following Jaeger CR can be used to provision a Jaeger instance suitable for non-production purposes: + +```yaml +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: jaeger +``` + +The Jaeger Operator also provides extensive logging when the flag `--log-level` is set to `debug`. Here's an excerpt from an `operator.yaml` that has the logging level set to debug: + +```yaml + # .Spec.Template.Spec.Containers[0].Args + args: ["start", "--log-level=debug"] +``` + +Note that tracing and logging at debug level can be both enabled at the same time. + +When using OLM, the Jaeger Operator can be configured by changing the `Subscription`'s `config` property. To set the `log-level` parameter, this is how a subscription would look like (excerpt): + +```yaml +apiVersion: operators.coreos.com/v1alpha1 +kind: Subscription +metadata: + name: jaeger + namespace: openshift-operators +spec: + channel: stable + config: + env: + - name: LOG-LEVEL + value: debug + installPlanApproval: Automatic + name: jaeger + source: community-operators + sourceNamespace: openshift-marketplace +``` + +# Monitoring the operator + +The Jaeger Operator starts a Prometheus-compatible endpoint on `0.0.0.0:8383/metrics` with internal metrics that can be used to monitor the process. Interesting metrics to watch are: + +``` +# Total number of reconciliations and their outcomes (cumulative) +controller_runtime_reconcile_total{controller="jaeger-controller",result="error"} +controller_runtime_reconcile_total{controller="jaeger-controller",result="success"} + +# Total number of retries (cumulative) +workqueue_retries_total{name="jaeger-controller"} + +# Current number of reconciliation loops in progress (gauge) +workqueue_depth{name="jaeger-controller"} + +# How long (in seconds) the oldest reconciliation loop is taking. (gauge) +workqueue_unfinished_work_seconds{name="jaeger-controller"} + +# How long (in seconds) it takes to process an item from the workqueue. (bucket) +workqueue_work_duration_seconds_bucket{name="jaeger-controller"} +``` + +A low number of reconciliation errors is normal (`controller_runtime_reconcile_total{controller="jaeger-controller",result="error"}`), as there might be several processes changing resources at the same time for different reasons. Whenever there's a failure, the operator will attempt to reconcile again, increasing the `workqueue_retries_total{name="jaeger-controller"}` metric. However, if the rate of errors over time keeps increasing, or is beyond a reasonable threshold, an investigation might be required. The reasonable threshold might differ from cluster to cluster depending on what's happening in it, but 10% is a good starting point. + +As of v1.17.0, the Jaeger Operator will trigger a reconciliation loop only when the custom resource has changed or when the previous reconciliation has failed. Therefore, it's normal to have this metric (`controller_runtime_reconcile_total{controller="jaeger-controller"}`) with the same value over a long period of time: it only indicates that the custom resource hasn't changed. If this number keeps changing every second, it's indicative that something in the cluster is periodically changing the custom resource, or that the Jaeger Operator is undoing a change that is being done by a different component. Future versions of the Jaeger Operator might trigger a periodic reconciliation loop. + +The work queue depth (`workqueue_depth{name="jaeger-controller"}`) indicates the number of currently active reconciliation loops. For small clusters, or clusters where provisioning of Jaeger instances aren't that frequent, this number should remain close to zero for most of the time. Any value that is higher than 0 for a sustained amount of time is an indication of a reconciliation loop that got stuck. If that happens, the metric `workqueue_unfinished_work_seconds{name="jaeger-controller"}` will also continually increase. This situation indicates a bug in the Jaeger Operator. As a rule of thumb, a reconciliation has to finish in a couple of minutes, except when provisioning of Elasticsearch or Kafka is involved. A reconciliation loop that takes more than 10 minutes can be considered as "stuck". Provisioning of Elasticsearch or Kafka might take several minutes. In the usual case, reconciliation loops will take under one minute to complete. + +The work queue buckets (`workqueue_unfinished_work_seconds{name="jaeger-controller"}` and `workqueue_work_duration_seconds_bucket{name="jaeger-controller"}`) are directly related to the time spent processing each reconciliation loop. It's normal that one of the first 3 loops of a new Jaeger instance will take far more time than the subsequent ones, especially if the container images for the underlying components aren't cached yet by the cluster. Using the auto-provisioning feature to create an Elasticsearch and/or Kafka cluster will also affects this metric. The general rule is: a few long-running reconciliation loops are normal, especially if they occur around the same time that the metric `controller_runtime_reconcile_total{controller="jaeger-controller"}` was increased. + +{{< info >}} +The Jaeger Operator does not yet publish its own metrics. Rather, it makes available metrics reported by the components it uses, such as the Operator SDK. +{{< /info >}} + +# Uninstalling the operator + + +To uninstall the operator, run the following commands: + +```bash +kubectl delete -n observability -f https://github.com/jaegertracing/jaeger-operator/releases/download/v{{< currentVersion >}}.0/jaeger-operator.yaml +``` diff --git a/content/docs/1.61/performance-tuning.md b/content/docs/1.61/performance-tuning.md new file mode 100644 index 00000000..6d019a1f --- /dev/null +++ b/content/docs/1.61/performance-tuning.md @@ -0,0 +1,116 @@ +--- +title: Performance Tuning Guide +navtitle: Perf Tuning +description: Tweaking your Jaeger instance to achieve a better performance +weight: 10 +--- + +Jaeger was built from day 1 to be able to ingest huge amounts of data in a resilient way. To better utilize resources that might cause delays, such as storage or network communications, Jaeger buffers and batches data. When more spans are generated than Jaeger is able to safely process, spans might get dropped. However, the defaults might not fit all scenarios. + +## Deployment considerations + +Although performance tuning the individual components is important, the way Jaeger is deployed can be decisive in obtaining optimal performance. + +### Scale the Collector up and down + +Use the auto-scaling capabilities of your platform: **jaeger-collector** is nearly horizontally scalable so that more instances can be added and removed on-demand. A good way to scale up and down is by checking the `jaeger_collector_queue_length` metric: add instances when the length is higher than 50% of the maximum size for extended periods of time. Another metric that can be taken into consideration is `jaeger_collector_in_queue_latency_bucket`, which is a histogram indicating how long spans have been waiting in the queue before a worker picked it up. When the queue latency gets higher over time, it’s a good indication to increase the number of the workers, or to improve the storage performance. + +Adding **jaeger-collector** instances is recommended when your platform provides auto-scaling capabilities, or when it's easier to start/stop **jaeger-collector** instances than changing existing, running instances. Scaling horizontally is also indicated when the CPU usage should be spread across nodes. + +### Make sure the storage can keep up + +Each span is written to the storage by **jaeger-collector** using one worker, blocking it until the span has been stored. When the storage is too slow, the number of workers blocked by the storage might be too high, causing spans to be dropped. To help diagnose this situation, the histogram `jaeger_collector_save_latency_bucket` can be analyzed. Ideally, the latency should remain the same over time. When the histogram shows that most spans are taking longer and longer over time, it’s a good indication that your storage might need some attention. + +### Place the Agents close to your applications + +{{< warning >}} +Since the Jaeger client libraries [are deprecated](../client-libraries) and the OpenTelemetry SDKs are phasing out support for Jaeger Thrift format, the **jaeger-agent** is no longer required or recommended. See the [Architecture](../architecture) page for alternative deployment options. +{{< /warning >}} + +**jaeger-agent** is meant to be placed on the same host as the instrumented application, in order to avoid UDP packet loss over the network. This is typically accomplished by having one **jaeger-agent** per bare metal host for traditional applications, or as a sidecar in container environments like Kubernetes, as this helps spread the load handled by **jaeger-agent**s with the additional advantage of allowing each **jaeger-agent** to be tweaked individually, according to the application’s needs and importance. + +### Consider using Apache Kafka as intermediate buffer + +Jaeger [can use Apache Kafka](../architecture/) as a buffer between **jaeger-collector** and the actual backing storage (Elasticsearch, Apache Cassandra). This is ideal for cases where the traffic spikes are relatively frequent (prime time traffic) but the storage can eventually catch up once the traffic normalizes. For that, the `SPAN_STORAGE_TYPE` environment variable should be set to `kafka` in **jaeger-collector**, and **jaeger-ingester** component must be used, reading data from Kafka and writing it to the storage. + +In addition to the performance aspects, having spans written to Kafka is useful for building real time data pipeline for aggregations and feature extraction from traces. + +**jaeger-collector**s can still be scaled in the same way as when writing to storage directly. The trace IDs are used as sharding keys for Kafka partitions, such that all spans for a given trace end up in the same partition of the Kafka topic. Each **jaeger-collector** can write to any partition. + +**jaeger-ingester**s can also be scaled as needed to sustain the throughput. They will automatically negotiate and rebalance Kafka partitions among them. However, it does not make sense to run more **jaeger-ingester**s than there are partitions in the Kafka topic, as in this case some of **jaeger-ingester**s will be idle. + +## Client (Tracer) settings + +{{< warning >}} +Jaeger clients have been retired. Please use the OpenTelemetry SDKs. +{{< /warning >}} + +The Jaeger Clients are built to have minimal effect to the instrumented application. As such, it has conservative defaults that might not be suitable for all cases. Note that Jaeger Clients can be configured programmatically or via [environment variables](../client-features/). + +### Adjust the sampling configuration + +Together, the `JAEGER_SAMPLER_TYPE` and `JAEGER_SAMPLER_PARAM` specify how often traces should be "sampled", ie, recorded and sent to the Jaeger backend. For applications generating many spans, setting the sampling type to `probabilistic` and the value to `0.001` (the default) will cause traces to be reported with a 1/1000th chance. Note that the sampling decision is made at the root span and propagated down to all child spans. + +For applications with low to medium traffic, setting the sampling type to `const` and value to `1` will cause all spans to be reported. Similarly, tracing can be disabled by setting the value to `0`, while context propagation will continue to work. + +Some Clients support the setting `JAEGER_DISABLED` to completely disable the Jaeger Tracer. This is recommended only if the Tracer is behaving in a way that causes problems to the instrumented application, as it will not propagate the context to the downstream services. + +{{< info >}} +We recommend setting your clients/SDKs to use the [`remote` sampling strategy](../sampling/#remote-sampling), so that admins can centrally set the concrete sampling strategy for each service. +{{< /info >}} + +### Increase in-memory queue size + +Most of the Jaeger clients, such as the Java, Go, and C# clients, buffer spans in memory before sending them to **jaeger-agent**/**jaeger-collector**. The maximum size of this buffer is defined by the environment variable `JAEGER_REPORTER_MAX_QUEUE_SIZE` (default value: about `100` spans): the larger the size, the higher the potential memory consumption. When the instrumented application is generating a large number of spans, it’s possible that the queue will be full causing the Client to discard the new spans (metric `jaeger_tracer_reporter_spans_total{result="dropped",}`). + +In most common scenarios, the queue will be close to empty (metric: `jaeger_tracer_reporter_queue_length`), as spans are flushed to **jaeger-agent** or **jaeger-collector** at regular intervals or when a certain size of the batch is reached. The detailed behavior of this queue is described in this [GitHub issue](https://github.com/jaegertracing/jaeger-client-java/issues/607). + +Thrift clients also report their dropped spans to **jaeger-agent**. These are then published by **jaeger-agent** itself as `jaeger_agent_client_stats_spans_dropped_total{cause="full-queue|send-failure|too-large",}`. This can be useful if client metrics are unavailable for some reason. + +### Modify the batched spans flush interval + +The Java, Go, NodeJS, Python and C# Clients allow the customization of the flush interval (default value: `1000` milliseconds, or 1 second) used by the reporters, such as the `RemoteReporter`, to trigger a `flush` operation, sending all in-memory spans to **jaeger-agent** or **jaeger-collector**. The lower the flush interval is set to, the more frequent the flush operations happen. As most reporters will wait until enough data is in the queue, this setting will force a flush operation at periodic intervals, so that spans are sent to the backend in a timely fashion. + +When the instrumented application is generating a large number of spans and **jaeger-agent**/**jaeger-collector** is close to the application, the networking overhead might be low, justifying a higher number of flush operations. When the `HttpSender` is being used and the **jaeger-collector** is not close enough to the application, the networking overhead might be too high so that a higher value for this property makes sense. + +## Agent settings + +{{< warning >}} +Since the Jaeger client libraries [are deprecated](../client-libraries) and the OpenTelemetry SDKs are phasing out support for Jaeger Thrift format, the **jaeger-agent** is no longer required or recommended. See the [Architecture](../architecture) page for alternative deployment options. +{{< /warning >}} + +**jaeger-agent**s receive data from Clients, sending them in batches to **jaeger-collector**. When not properly configured, it might end up discarding data even if the host machine has plenty of resources. + +### Adjust server queue sizes + +The set of “server queue size” properties ( `processor.jaeger-binary.server-queue-size`, `processor.jaeger-compact.server-queue-size`, `processor.zipkin-compact.server-queue-size`) indicate the maximum number of span batches that **jaeger-agent** can accept and store in memory. It’s safe to assume that `jaeger-compact` is the most important processor in your **jaeger-agent** setup, as it’s the only one available in most Clients, such as the Java and Go Clients. + +The default value for each queue is `1000` span batches. Given that each span batch has up to 64KiB worth of spans, each queue can hold up to 64MiB worth of spans. + +In typical scenarios, the queue will be close to empty (metric `jaeger_agent_thrift_udp_server_queue_size`) as span batches should be quickly picked up and processed by a worker. However, sudden spikes in the number of span batches submitted by Clients might occur, causing the batches to be queued. When the queue is full, the older batches are overridden causing spans to be discarded (metric `jaeger_agent_thrift_udp_server_packets_dropped_total`). + +### Adjust processor workers + +The set of “processor workers” properties ( `processor.jaeger-binary.workers`, `processor.jaeger-compact.workers`, `processor.zipkin-compact.workers`) indicate the number of parallel span batch processors to start. Each worker type has a default size of `10`. In general, span batches are processed as soon as they are placed in the server queue and will block a worker until the whole packet is sent to **jaeger-collector**. For **jaeger-agent**s processing data from multiple Clients, the number of workers should be increased. Given that the cost of each worker is low, a good rule of thumb is 10 workers per Client with moderate traffic: given that each span batch might contain up to 64KiB worth of spans, it means that 10 workers are able to send about 640KiB concurrently to a **jaeger-collector**. + +## Collector settings + +**jaeger-collector** receives data from Clients and **jaeger-agent**s. When not properly configured, it might process less data than what would be possible on the same host, or it might overload the host by consuming more memory than permitted. + +### Adjust queue size + +Similar to the **jaeger-agent**, **jaeger-collector** is able to receive spans and place them in an internal queue for processing. This allows **jaeger-collector** to return immediately to the Client/**jaeger-agent** instead of waiting for the span to make its way to the storage. + +The setting `collector.queue-size` (default: `2000`) dictates how many spans the queue should support. In the typical scenario, the queue will be close to empty, as enough workers should exist picking up spans from the queue and sending them to the storage. When the number of items in the queue (metric `jaeger_collector_queue_length`) is permanently high, it’s an indication that either the number of workers should be increased or that the storage cannot keep up with the volume of data that it’s receiving. When the queue is full, the older items in the queue are overridden, causing spans to be discarded (metric `jaeger_collector_spans_dropped_total`). + +{{< warning >}} +The queue size for **jaeger-agent** is about _span batches_, whereas the queue size for the Collector is about _individual spans_. +{{< /warning >}} + +Given that the queue size should be close to empty most of the time, this setting should be as high as the available memory for the Collector, to provide maximum protection against sudden traffic spikes. However, if your storage layer is under-provisioned and cannot keep up, even a large queue will quickly fill up and start dropping data. + +Experimental: starting from Jaeger 1.17, **jaeger-collector** can adjust the queue size automatically based on the memory requirements and average span size. Set the flag `collector.queue-size-memory` to the maximum memory size in MiB that **jaeger-collector** should use, and Jaeger will periodically calculate the ideal queue size based on the average span size it has seen. For safety reasons, the maximum queue size is hard-coded to 1 million records. If you are using this feature, [give us your feedback](https://www.jaegertracing.io/get-in-touch/)! + +### Adjust processor workers + +Items from the span queue in **jaeger-collector** are picked up by workers. Each worker picks one span from the queue and persists it to the storage. The number of workers can be specified by the setting `collector.num-workers` (default: `50`) and should be as high as needed to keep the queue close to zero. The general rule is: the faster the backing storage, the lower the number of workers can be. Given that workers are relatively cheap, this number can be increased at will. As a general rule, one worker per 50 items in the queue should be sufficient when the storage is fast. With a `collector.queue-size` of `2000`, having about `40` workers should be sufficient. For slower storage mechanisms, this ratio should be adjusted accordingly, having more workers per queue item. diff --git a/content/docs/1.61/sampling.md b/content/docs/1.61/sampling.md new file mode 100644 index 00000000..01e818db --- /dev/null +++ b/content/docs/1.61/sampling.md @@ -0,0 +1,99 @@ +--- +title: Sampling +hasparent: true +--- + +Jaeger libraries implement consistent upfront (or head-based) sampling. For example, assume we have a simple call graph where service A calls service B, and B calls service C: `A -> B -> C`. When service A receives a request that contains no tracing information, Jaeger tracer will start a new trace, assign it a random trace ID, and make a sampling decision based on the currently installed sampling strategy. The sampling decision will be propagated with the requests to B and to C, so those services will not be making the sampling decision again but instead will respect the decision made by the top service A. This approach guarantees that if a trace is sampled, all its spans will be recorded in the backend. If each service was making its own sampling decision we would rarely get complete traces in the backend. + +## Client Sampling Configuration + +{{< warning >}} +This section only applies to classic Jaeger SDKs, which are now deprecated. +We recommend using the [OpenTelemetry SDKs](https://opentelemetry.io). +{{< /warning >}} + +When using configuration object to instantiate the tracer, the type of sampling can be selected via `sampler.type` and `sampler.param` properties. Jaeger libraries support the following samplers: + +* **Constant** (`sampler.type=const`) sampler always makes the same decision for all traces. It either samples all traces (`sampler.param=1`) or none of them (`sampler.param=0`). +* **Probabilistic** (`sampler.type=probabilistic`) sampler makes a random sampling decision with the probability of sampling equal to the value of `sampler.param` property. For example, with `sampler.param=0.1` approximately 1 in 10 traces will be sampled. +* **Rate Limiting** (`sampler.type=ratelimiting`) sampler uses a leaky bucket rate limiter to ensure that traces are sampled with a certain constant rate. For example, when `sampler.param=2.0` it will sample requests with the rate of 2 traces per second. +* **Remote** (`sampler.type=remote`, which is also the default) sampler consults **jaeger-agent** for the appropriate sampling strategy to use in the current service. This allows controlling the sampling strategies in the services from a central configuration in Jaeger backend (see [Remote Sampling](#remote-sampling)), or even dynamically (see [Adaptive Sampling](#adaptive-sampling)). + +## Remote Sampling + +If your client SDKs are configured to use remote sampling configuration (see [Remote Sampling API][remote-sampling-api]) then sampling rates can be centrally controlled via **jaeger-collector**s. In this setup a sampling strategy configuration is served to the client SDK that describes endpoints and their sampling probabilities. This configuration can be generated by **jaeger-collector** in two different ways: [periodically loaded from a file](#file-based-sampling-configuration) or [dynamically calculated based on traffic](#adaptive-sampling). The method of generation is controlled by the environment variable `SAMPLING_CONFIG_TYPE` which can be set to either `file` (default) or `adaptive`. + +[remote-sampling-api]: ../apis#remote-sampling-configuration-stable + +### File-based Sampling Configuration + +**jaeger-collector**s can be instantiated with the `--sampling.strategies-file` option that points to a file containing sampling strategies to be served to Jaeger clients. The option's value can contain a path to a JSON file, which will be automatically reloaded if its contents change, or an HTTP URL from where the file will be periodically retrieved, with reload frequency controlled by the `--sampling.strategies-reload-interval` option. + +If no configuration is provided, **jaeger-collector**s will return the default probabilistic sampling policy with probability 0.001 (0.1%) for all services. + +Example `strategies.json`: +```json +{ + "service_strategies": [ + { + "service": "foo", + "type": "probabilistic", + "param": 0.8, + "operation_strategies": [ + { + "operation": "op1", + "type": "probabilistic", + "param": 0.2 + }, + { + "operation": "op2", + "type": "probabilistic", + "param": 0.4 + } + ] + }, + { + "service": "bar", + "type": "ratelimiting", + "param": 5 + } + ], + "default_strategy": { + "type": "probabilistic", + "param": 0.5, + "operation_strategies": [ + { + "operation": "/health", + "type": "probabilistic", + "param": 0.0 + }, + { + "operation": "/metrics", + "type": "probabilistic", + "param": 0.0 + } + ] + } +} +``` + +`service_strategies` element defines service specific sampling strategies and `operation_strategies` defines operation specific sampling strategies. There are 2 types of strategies possible: `probabilistic` and `ratelimiting` which are described [above](#client-sampling-configuration) (NOTE: `ratelimiting` is not supported for `operation_strategies`). `default_strategy` defines the catch-all sampling strategy that is propagated if the service is not included as part of `service_strategies`. + +In the above example: + +* All operations of service `foo` are sampled with probability 0.8 except for operations `op1` and `op2` which are probabilistically sampled with probabilities 0.2 and 0.4 respectively. +* All operations for service `bar` are rate-limited at 5 traces per second. +* Any other service will be sampled with probability 0.5 defined by the `default_strategy`. +* The `default_strategy` also includes shared per-operation strategies. In this example we disable tracing on `/health` and `/metrics` endpoints for all services by using probability 0. These per-operation strategies will apply to any new service not listed in the config, as well as to the `foo` and `bar` services unless they define their own strategies for these two operations. + +### Adaptive Sampling + +Since Jaeger v1.27. + +Adaptive sampling works in **jaeger-collector** by observing the spans received from services and recalculating sampling probabilities for each service/endpoint combination to ensure that the volume of collected traces matches `--sampling.target-samples-per-second`. When a new service or endpoint is detected, it is initially sampled with `--sampling.initial-sampling-probability` until enough data is collected to calculate the rate appropriate for the traffic going through the endpoint. + +Adaptive sampling requires a storage backend to store the observed traffic data and computed probabilities. At the moment `memory` (for all-in-one deployment), `cassandra`, `badger`, `elasticsearch` and `opensearch` are supported as sampling storage backends. + +By default adaptive sampling will attempt to use the backend specified by `SPAN_STORAGE_TYPE` to store data. However, a second type of backend can also be specified by using `SAMPLING_STORAGE_TYPE`. For instance, `SPAN_STORAGE_TYPE=elasticsearch SAMPLING_STORAGE_TYPE=cassandra ./jaeger-collector` will run **jaeger-collector** in a mode where it attempts to store its span data in the configured elasticsearch cluster and its adaptive sampling data in the configured cassandra cluster. Note that this feature can not be used to store span and adaptive sampling data in two different backends of the same type. + +Read [this blog post](https://medium.com/jaegertracing/adaptive-sampling-in-jaeger-50f336f4334) for more details on adaptive sampling engine. diff --git a/content/docs/1.61/security.md b/content/docs/1.61/security.md new file mode 100644 index 00000000..3c47787f --- /dev/null +++ b/content/docs/1.61/security.md @@ -0,0 +1,52 @@ +--- +title: Securing Jaeger Installation +hasparent: true +--- + +This page documents the existing security mechanisms in Jaeger, organized by the pairwise connections between Jaeger components. We ask for community help with implementing additional security measures (see [issue-1718][]). + +## SDK to Agent + +{{< warning >}} +**jaeger-agent** is [deprecated](https://github.com/jaegertracing/jaeger/issues/4739). The OpenTelemetry data can be sent from the OpenTelemetry SDKs (equipped with OTLP exporters) directly to **jaeger-collector**. Alternatively, use the OpenTelemetry Collector as a local agent. +{{< /warning >}} + +Deployments that involve **jaeger-agent** are meant for trusted environments where the agent is run as a sidecar within the container's network namespace, or as a host agent. Therefore, there is currently no support for traffic encryption between clients and agents. + +* {{< check_no >}} Sending trace data over UDP - no TLS/authentication. +* {{< check_no >}} Retrieving sampling configuration via HTTP - no TLS/authentication. + +## SDK to Collector + +OpenTelemetry SDKs can be configured to communicate directly with **jaeger-collector** via gRPC or HTTP, with optional TLS enabled. + +* {{< check_yes >}} HTTP - TLS with mTLS (client cert authentication) supported. +* {{< check_yes >}} gRPC - TLS with mTLS (client cert authentication) supported. + * Covers both span export and sampling configuration querying. + +## Agent to Collector + +{{< warning >}} +**jaeger-agent** is [deprecated](https://github.com/jaegertracing/jaeger/issues/4739). +{{< /warning >}} + +* {{< check_yes >}} gRPC - TLS with client cert authentication supported. + +## Collector/Ingester/Query-Service to Storage + +* {{< check_yes >}} Cassandra - TLS with mTLS (client cert authentication) supported. +* {{< check_yes >}} Elasticsearch - TLS with mTLS (client cert authentication) supported; bearer token propagation. +* {{< check_yes >}} Kafka - TLS with various authentication mechanisms supported (mTLS, Kerberos, plaintext). + +## Browser to UI + +* {{< check_no >}} HTTP - no TLS; bearer token authentication (pass-through to storage). + * Blog post: [Protecting Jaeger UI with an OAuth sidecar Proxy](https://medium.com/jaegertracing/protecting-jaeger-ui-with-an-oauth-sidecar-proxy-34205cca4bb1). + * Blog post: [Secure architecture for Jaeger with Apache httpd reverse proxy on OpenShift](https://medium.com/@larsmilland01/secure-architecture-for-jaeger-with-apache-httpd-reverse-proxy-on-openshift-f31983fad400). + +## Consumers to Query Service + +* {{< check_yes >}} HTTP - TLS with mTLS (client cert authentication) supported. +* {{< check_yes >}} gRPC - TLS with mTLS (client cert authentication) supported. + +[issue-1718]: https://github.com/jaegertracing/jaeger/issues/1718 diff --git a/content/docs/1.61/spm.md b/content/docs/1.61/spm.md new file mode 100644 index 00000000..b1b8fb93 --- /dev/null +++ b/content/docs/1.61/spm.md @@ -0,0 +1,374 @@ +--- +title: Service Performance Monitoring (SPM) +hasparent: true +--- + +![Service Performance Monitoring](/img/frontend-ui/spm.png) + +Surfaced in Jaeger UI as the "Monitor" tab, the motivation for this feature is +to help identify interesting traces (e.g. high QPS, slow or erroneous requests) +without needing to know the service or operation names up-front. + +It is essentially achieved through aggregating span data to produce RED +(Request, Error, Duration) metrics. + +Potential use cases include: + +- Post deployment sanity checks across the org, or on known dependent services + in the request chain. +- Monitoring and root-causing when alerted of an issue. +- Better onboarding experience for new users of Jaeger UI. +- Long-term trend analysis of QPS, errors and latencies. +- Capacity planning. + +## UI Feature Overview + +The "Monitor" tab provides a service-level aggregation, as well as an operation-level +aggregation within the service, of Request rates, Error rates and Durations +(P95, P75 and P50), also known as RED metrics. + +Within the operation-level aggregations, an "Impact" metric, computed as the +product of latency and request rate, is another signal that can be used to +rule-out operations that may naturally have a high latency profile such as daily +batch jobs, or conversely highlight operations that are lower in the latency +rankings but with a high RPS (request per second). + +From these aggregations, Jaeger UI is able to pre-populate a Trace search with +the relevant service, operation and lookback period, narrowing down the search +space for these more interesting traces. + +## Getting Started + +{{< info >}} +This is for demonstration purposes only and does not reflect deployment best practices. +{{< /info >}} + +A locally runnable setup is available in the [Jaeger repository][spm-demo] along +with instructions on how to run it. + +The feature can be accessed from the "Monitor" tab along the top menu. + +This demo includes [Microsim](https://github.com/yurishkuro/microsim); a microservices +simulator to generate trace data. + +If generating traces manually is preferred, the [Sample App: HotROD](../getting-started/#sample-app-hotrod) +can be started via docker. Be sure to include `--net monitor_backend` in the `docker run` command. + +## Architecture + +The RED metrics queried by Jaeger for the Monitor tab are the result of span +data collected by the [OpenTelemetry Collector][opentelemetry-collector] which +is then aggregated by the [SpanMetrics Connector][spanmetrics-conn] component configured +within its pipeline. + +These metrics are finally exported by the OpenTelemetry Collector (via prometheus +exporters) to a Prometheus-compatible metrics store. + +It is important emphasize that this is a "read-only" feature and, +as such, is only relevant to the Jaeger Query component (and All In One). + +{{}} +graph + OTLP_EXPORTER[OTLP Exporter] --> TRACE_RECEIVER + + subgraph Service + subgraph OpenTelemetry SDK + OTLP_EXPORTER + end + end + + TRACE_RECEIVER[Trace Receiver] --> |spans| SPANMETRICS_CONN[SpanMetrics Connector] + TRACE_RECEIVER --> |spans| TRACE_EXPORTER[Trace Exporter] + TRACE_EXPORTER --> |spans| COLLECTOR[Jaeger Collector] + SPANMETRICS_CONN --> |metrics| PROMETHEUS_EXPORTER[Prometheus/PromethesusRemoteWrite Exporter] + PROMETHEUS_EXPORTER --> |metrics| METRICS_STORE[(Metrics Storage)] + + COLLECTOR --> |spans| SPAN_STORE[(Span Storage)] + SPAN_STORE --> QUERY[Jaeger Query] + METRICS_STORE --> QUERY + QUERY --> UI[Jaeger UI] + + subgraph OpenTelemetry Collector + subgraph Pipeline + TRACE_RECEIVER + SPANMETRICS_CONN + TRACE_EXPORTER + PROMETHEUS_EXPORTER + end + end + + style Service fill:#DFDFDF,color:black + + style OTLP_EXPORTER fill:#404CA8,color:white + style TRACE_RECEIVER fill:#404CA8,color:white + style TRACE_EXPORTER fill:#404CA8,color:white + style SPANMETRICS_CONN fill:#404CA8,color:white + style PROMETHEUS_EXPORTER fill:#404CA8,color:white + + style UI fill:#9AEBFE,color:black + style QUERY fill:#9AEBFE,color:black + style COLLECTOR fill:#9AEBFE,color:black +{{< /mermaid >}} + +## Derived Time Series + +Though more in scope of the [OpenTelemetry Collector][opentelemetry-collector], +it is worth understanding the additional metrics and time series that the +[SpanMetrics Connector][spanmetrics-conn] will generate in metrics storage to help +with capacity planning when deploying SPM. + +Please refer to [Prometheus documentation][prom-metric-labels] covering the +concepts of metric names, types, labels and time series; terms that will be used +in the remainder of this section. + +Two metric names will be created: +- `calls_total` + - **Type**: counter + - **Description**: counts the total number of spans, including error spans. + Call counts are differentiated from errors via the `status_code` label. Errors + are identified as any time series with the label `status_code = "STATUS_CODE_ERROR"`. +- `[namespace_]duration_[units]` + - **Type**: histogram + - **Description**: a histogram of span durations/latencies. Under the hood, Prometheus histograms + will create a number of time series. For illustrative purposes, assume no namespace + is configured and the units are `milliseconds`: + - `duration_milliseconds_count`: The total number of data points across all buckets in the histogram. + - `duration_milliseconds_sum`: The sum of all data point values. + - `duration_milliseconds_bucket`: A collection of `n` time series (where `n` is the number of + duration buckets) for each duration bucket identified by an `le` (less than + or equal to) label. The `duration_milliseconds_bucket` counter with lowest `le` and + `le >= span duration` will be incremented for each span. + +The following formula aims to provide some guidance on the number of new time series created: +``` +num_status_codes * num_span_kinds * (1 + num_latency_buckets) * num_operations + +Where: + num_status_codes = 3 max (typically 2: ok/error) + num_span_kinds = 6 max (typically 2: client/server) + num_latency_buckets = 17 default +``` + +Plugging those numbers in, assuming default configuration: +``` +max = 324 * num_operations +typical = 72 * num_operations +``` + +Note: +- Custom [duration buckets][spanmetrics-config-duration] or [dimensions][spanmetrics-config-dimensions] + configured in the spanmetrics connector will alter the calculation above. +- Querying custom dimensions are not supported by SPM and will be aggregated over. + +## Configuration + +### Enabling SPM + +The following configuration is required to enable the SPM feature: + +- [Jaeger UI](../frontend-ui#monitor) +- [Jaeger Query](../cli#jaeger-query-prometheus) + - Set the `METRICS_STORAGE_TYPE` environment variable to `prometheus`. + - Optional: Set `--prometheus.server-url` (or `PROMETHEUS_SERVER_URL` environment variable) + to the URL of the prometheus server. Default: http://localhost:9090. + - Optional: Set `--prometheus.query.support-spanmetrics-connector=true` to explicitly enable the [SpanMetrics Connector][spanmetrics-conn] if you intend to use it. This will become the default behavior in the future. + + +## API + +### gRPC/Protobuf + +The recommended way to programmatically retrieve RED metrics is via `jaeger.api_v2.metrics.MetricsQueryService` gRPC endpoint defined in the [metricsquery.proto][metricsquery.proto] IDL file. + +### HTTP JSON + +Used internally by the Monitor tab of Jaeger UI to populate the metrics for its visualizations. + +Refer to [this README file][http-api-readme] for a detailed specification of +the HTTP API. + +## Troubleshooting + +### Check the /metrics endpoint + +The `/metrics` endpoint can be used to check if spans for specific services were received. +The `/metrics` endpoint is served from the admin port. +Assuming that Jaeger all-in-one and query are available under hosts named `all-in-one` +and `jaeger-query` respectively, here are sample `curl` calls to obtain the metrics: + +```shell +$ curl http://all-in-one:14269/metrics + +$ curl http://jaeger-query:16687/metrics +``` + +The following metrics are of most interest: + +```shell +# all-in-one +jaeger_requests_total +jaeger_latency_bucket + +# jaeger-query +jaeger_query_requests_total +jaeger_query_latency_bucket +``` + +Each of these metrics will have a label for each of the following operations: +```shell +get_call_rates +get_error_rates +get_latencies +get_min_step_duration +``` + +If things are working as expected, the metrics with label `result="ok"` should +be incrementing, and `result="err"` being static. For example: +```shell +jaeger_query_requests_total{operation="get_call_rates",result="ok"} 18 +jaeger_query_requests_total{operation="get_error_rates",result="ok"} 18 +jaeger_query_requests_total{operation="get_latencies",result="ok"} 36 + +jaeger_query_latency_bucket{operation="get_call_rates",result="ok",le="0.005"} 5 +jaeger_query_latency_bucket{operation="get_call_rates",result="ok",le="0.01"} 13 +jaeger_query_latency_bucket{operation="get_call_rates",result="ok",le="0.025"} 18 + +jaeger_query_latency_bucket{operation="get_error_rates",result="ok",le="0.005"} 7 +jaeger_query_latency_bucket{operation="get_error_rates",result="ok",le="0.01"} 13 +jaeger_query_latency_bucket{operation="get_error_rates",result="ok",le="0.025"} 18 + +jaeger_query_latency_bucket{operation="get_latencies",result="ok",le="0.005"} 7 +jaeger_query_latency_bucket{operation="get_latencies",result="ok",le="0.01"} 25 +jaeger_query_latency_bucket{operation="get_latencies",result="ok",le="0.025"} 36 +``` + +If there are issues reading metrics from Prometheus such as a failure to reach +the Prometheus server, then the `result="err"` metrics will be incremented. For example: +```shell +jaeger_query_requests_total{operation="get_call_rates",result="err"} 4 +jaeger_query_requests_total{operation="get_error_rates",result="err"} 4 +jaeger_query_requests_total{operation="get_latencies",result="err"} 8 +``` + +At this point, checking the logs will provide more insight towards root causing +the problem. + +### Query Prometheus + +Graphs may still appear empty even when the above Jaeger metrics indicate successful reads +from Prometheus. In this case, query Prometheus directly on any of these metrics: + +- `duration_bucket` +- `duration_milliseconds_bucket` +- `duration_seconds_bucket` +- `calls` +- `calls_total` + +You should expect to see these counters increasing as spans are being emitted +by services to the OpenTelemetry Collector. + +### Viewing Logs + +If the above metrics are present in Prometheus, but not appearing in the Monitor +tab, it means there is a discrepancy between what metrics Jaeger expects to see in +Prometheus and what metrics are actually available. + +This can be confirmed by increasing the log level by setting the following +environment variable: + +```shell +LOG_LEVEL=debug +``` + +Outputting logs that resemble the following: +```json +{ + "level": "debug", + "ts": 1688042343.4464543, + "caller": "metricsstore/reader.go:245", + "msg": "Prometheus query results", + "results": "", + "query": "sum(rate(calls{service_name =~ \"driver\", span_kind =~ \"SPAN_KIND_SERVER\"}[10m])) by (service_name,span_name)", + "range": + { + "Start": "2023-06-29T12:34:03.081Z", + "End": "2023-06-29T12:39:03.081Z", + "Step": 60000000000 + } +} +``` + +In this instance, let's say OpenTelemetry Collector's `prometheusexporter` introduced +a breaking change that appends a `_total` suffix to counter metrics and the duration units within +histogram metrics (e.g. `duration_milliseconds_bucket`). As we discovered, +Jaeger is looking for the `calls` (and `duration_bucket`) metric names, +while the OpenTelemetry Collector is writing `calls_total` (and `duration_milliseconds_bucket`). + +The resolution, in this specific case, is to set environment variables telling Jaeger +to normalize the metric names such that it knows to search for `calls_total` and +`duration_milliseconds_bucket` instead, like so: + +```shell +PROMETHEUS_QUERY_NORMALIZE_CALLS=true +PROMETHEUS_QUERY_NORMALIZE_DURATION=true +``` + +### Checking OpenTelemetry Collector Config + +If there are error spans appearing in Jaeger, but no corresponding error metrics: + +- Check that raw metrics in Prometheus generated by the spanmetrics connector + (as listed above: `calls`, `calls_total`, `duration_bucket`, etc.) contain + the `status.code` label in the metric that the span should belong to. +- If there are no `status.code` labels, check the OpenTelemetry Collector + configuration file, particularly for the presence of the following configuration: + ```yaml + exclude_dimensions: ['status.code'] + ``` + This label is used by Jaeger to determine if a request is erroneous. + +### Inspect the OpenTelemetry Collector + +If the above `latency_bucket` and `calls_total` metrics are empty, then it could +be misconfiguration in the OpenTelemetry Collector or anything upstream from it. + +Some questions to ask while troubleshooting are: +- Is the OpenTelemetry Collector configured correctly? + - See: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/connector/spanmetricsconnector +- Is the Prometheus server reachable by the OpenTelemetry Collector? +- Are the services sending spans to the OpenTelemetry Collector? + - See: https://github.com/open-telemetry/opentelemetry-collector/blob/main/docs/troubleshooting.md + +### Service/Operation missing in Monitor Tab + +If the service/operation is missing in the Monitor Tab, but visible in the Jaeger +Trace search service and operation drop-downs menus, a common cause of this is +the default `server` span kind used in metrics queries. + +The service/operations you are not seeing could be from spans that are non-server +span kinds such as client or worse, `unspecified`. Hence, this is an instrumentation +data quality issue, and the instrumentation should set the span kind. + +The reason for defaulting to `server` span kinds is to avoid double-counting +both ingress and egress spans in the `server` and `client` span kinds, respectively. + +[spm-demo]: https://github.com/jaegertracing/jaeger/tree/main/docker-compose/monitor +[metricsquery.proto]: https://github.com/jaegertracing/jaeger/blob/main/model/proto/metrics/metricsquery.proto +[openmetrics.proto]: https://github.com/jaegertracing/jaeger/blob/main/model/proto/metrics/openmetrics.proto#L53 +[opentelemetry-collector]: https://opentelemetry.io/docs/collector/ +[spanmetrics]: https://pkg.go.dev/github.com/open-telemetry/opentelemetry-collector-contrib/processor/spanmetricsprocessor#section-readme +[spanmetrics-conn]: https://pkg.go.dev/github.com/open-telemetry/opentelemetry-collector-contrib/connector/spanmetricsconnector#section-readme +[prom-metric-labels]: https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels +[http-api-readme]: https://github.com/jaegertracing/jaeger/tree/main/docker-compose/monitor#http-api +[spanmetrics-config-dimensions]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/connector/spanmetricsconnector/testdata/config.yaml#L23 +[spanmetrics-config-duration]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/connector/spanmetricsconnector/testdata/config.yaml#L14 + +### 403 when executing metrics query + +If logs contain the error resembling: `failed executing metrics query: client_error: client error: 403`, +it is possible that the Prometheus server is expecting a bearer token. + +Jaeger Query (and all-in-one) can be configured to pass the bearer token in +metrics queries via the `--prometheus.token-file` command-line parameter +(or the `PROMETHEUS_TOKEN_FILE` environment variable), with its value set to +the path of the file containing the bearer token. diff --git a/content/docs/1.61/tools.md b/content/docs/1.61/tools.md new file mode 100644 index 00000000..71ad83a3 --- /dev/null +++ b/content/docs/1.61/tools.md @@ -0,0 +1,29 @@ +--- +title: Tools +navtitle: Tools +description: Extra Jaeger utilities. +weight: 12 +--- + +## Tracegen + +It is a powerful utility that can be used to generate continuous stream of simple spans. This is specially useful for stress testing. It supports flags to control the number of workers and number of traces to generate in each worker. Not only that, it can generate spans in firehose mode (a flag set on spans to skip indexing). + +```sh +docker run \ + --rm \ + jaegertracing/jaeger-tracegen:{{< currentVersion >}} +``` + +## Anonymizer + +It is a small utility that expects a trace-id and outputs an anonymized json version of that trace. This is useful in case you want to share your span with someone for purposes like debugging. By anonymized version, we mean that it removes or hashes details which are particular to your environment and you're not comfortable sharing them. + +```sh +docker run \ + --rm \ + --volume /tmp:/tmp \ + jaegertracing/jaeger-anonymizer:{{< currentVersion >}} \ + --trace-id \ + --query-host-port +``` diff --git a/content/docs/1.61/troubleshooting.md b/content/docs/1.61/troubleshooting.md new file mode 100644 index 00000000..90487924 --- /dev/null +++ b/content/docs/1.61/troubleshooting.md @@ -0,0 +1,140 @@ +--- +title: Troubleshooting +description: Solve commonly encountered issues +weight: 10 +--- + +Jaeger backend is itself a distributed system, composed of different components, potentially running on many hosts. It might be the case that one of these moving parts is not working properly, causing spans to not be processed or stored. When something goes wrong, make sure to check the items listed here. + +If you are using the OpenTelemetry Collector as part of your pipeline, make sure to check its own [Troubleshooting guide](https://github.com/open-telemetry/opentelemetry-collector/blob/main/docs/troubleshooting.md). + +## Verify the sampling strategy + +Before everything else, make sure to confirm what sampling strategy is being used. For development purposes or for low-traffic scenarios, it is useful to sample every trace. In production, you may want to use lower rates. When diagnosing why spans are not being received by the backend, make sure to configure the SDK to _sample every trace_. Typically, the sampling strategy can be set via environment variables. + +### OpenTelemetry SDKs + +If you are using OpenTelemetry SDKs, they should default to `parentbased_always_on` sampler, which is effectively sampling at 100%. It can be changed via `OTEL_TRACES_SAMPLER` environment variable ([see documentation](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/configuration/sdk-environment-variables.md)). + +#### Using stdout Exporter + +OpenTelemetry SDKs can be configured with an exporter that prints recorded spans to `stdout`. Enabling it allows you to verify if the spans are actually being recorded. + +### Jaeger SDKs (deprecated) + +If you are using one of the Jaeger SDKs, they default to a probabilistic sampling strategy with `1-in-1000` chance that the trace will be recorded. The strategy can be changed by setting these environment variables: + +``` +JAEGER_SAMPLER_TYPE=const +JAEGER_SAMPLER_PARAM=1 +``` + +For example, when using the Jaeger SDK for Java, the strategy is usually printed out via the logging facility provided by the instrumented application when creating the tracer: + + 2018-12-10 16:41:25 INFO Configuration:236 - Initialized tracer=JaegerTracer(..., sampler=ConstSampler(decision=true, tags={sampler.type=const, sampler.param=true}), ...) + +#### Use the logging reporter + +Most Jaeger SDKs are able to log the spans that are being reported to the logging facility provided by the instrumented application. Typically, this can be done by setting the environment variable `JAEGER_REPORTER_LOG_SPANS` to `true`, but refer to the Jaeger SDK's documentation for the language you are using. In some languages, specifically in Go and Node.js, there are no de-facto standard logging facilities, so you need to explicitly pass a logger to the SDK that implements a very narrow `Logger` interface defined by the Jaeger SDKs. When using the Jaeger SDK for Java, spans are reported like the following: + + 2018-12-10 17:20:54 INFO LoggingReporter:43 - Span reported: e66dc77b8a1e813b:6b39b9c18f8ef082:a56f41e38ca449a4:1 - getAccountFromCache + +The log entry above contains three IDs: the trace ID `e66dc77b8a1e813b`, the span ID `6b39b9c18f8ef082` and the span's parent ID `a56f41e38ca449a4`. When the backend components have the log level set to `debug`, the span and trace IDs should be visible on their standard output (see [Increase the logging in the backend components](#increase-the-logging-in-the-backend-components) below). + +The logging reporter follows the sampling decision made by the sampler, meaning that if the span is logged, it should also reach the backend. + +### Remote Sampling + +The Jaeger backend supports [Remote Sampling](../sampling/#remote-sampling), i.e., configuring sampling strategies centrally and making them available to the SDKs. All Jaeger SDKs support it by setting `JAEGER_SAMPLER_TYPE=remote`. Some, but not all, OpenTelemetry SDKs also support remote sampling, often via extensions (refer to [Migration to OpenTelemetry](../client-libraries/#migration-to-opentelemetry) for details). + +If you suspect the remote sampling is not working correctly, try these steps: + +1. Make sure that the SDK is actually configured to use remote sampling, points to the correct sampling service address (see [APIs](../apis/#remote-sampling-configuration-stable)), and that address is reachable from your application's [networking namespace](#networking-namespace). +1. Look at the root span of the traces that are captured in Jaeger. If you are using Jaeger SDKs, the root span will contain the tags `sampler.type` and `sampler.param`, which indicate which strategy was used. (TBD - do OpenTelemetry SDKs record that?) +1. Verify that the server is returning the appropriate sampling strategy for your service: +``` + $ curl "jaeger-collector:14268/api/sampling?service=foobar" + {"strategyType":"PROBABILISTIC","probabilisticSampling":{"samplingRate":0.001}} +``` + +## Bypass the Jaeger Agent + +{{< warning >}} +This only applies when using Jaeger SDKs. The use of **jaeger-agent** [is deprecated](../deployment/#agent) when using OpenTelemetry SDKs. +{{< /warning >}} + +By default, the Jaeger SDK is configured to send spans via UDP to a **jaeger-agent** running on `localhost`. As some networking setups might drop or block UDP packets, or impose size limits, the Jaeger SDK can be configured to bypass **jaeger-agent**, sending spans directly to **jaeger-collector**. Some SDKs, such as the Jaeger SDK for Java, support the environment variable `JAEGER_ENDPOINT` which can be used to specify **jaeger-collector**'s location, such as `http://jaeger-collector:14268/api/traces`. Refer to the Jaeger SDK documentation for the language you are using. For example, when you have configured the `JAEGER_ENDPOINT` property in the Jaeger SDK for Java, it logs the following when the tracer is created (notice `sender=HttpSender`): + + 2018-12-10 17:06:30 INFO Configuration:236 - Initialized tracer=JaegerTracer(..., reporter=CompositeReporter(reporters=[RemoteReporter(sender=HttpSender(), ...), ...]), ...) + +Note: the Jaeger SDK for Java will not fail when a connection to **jaeger-collector** cannot be established. Spans will be collected and placed in an internal buffer. They might eventually reach **jaeger-collector** once a connection is established, or get dropped in case the buffer reaches its maximum size. + +## Networking Namespace + +If your Jaeger backend is still not able to receive spans (see the following sections on how to check logs and metrics for that), then the issue is most likely with your networking namespace configuration. When running the Jaeger backend components as Docker containers, the typical mistakes are: + + * Not exposing the appropriate ports outside of the container. For example, the collector may be listening on `:14268` inside the container network namespace, but the port is not reachable from the outside. + * Not making **jaeger-agent**'s or **jaeger-collector**'s host name visible from the application's network namespace. For example, if you run both your application and Jaeger backend in separate containers in Docker, they either need to be in the same namespace, or the application's container needs to be given access to Jaeger backend using the `--link` option of the `docker` command. + +## Increase the logging in the backend components + +**jaeger-agent** and **jaeger-collector** provide useful debugging information when the log level is set to `debug`. Every UDP packet that is received by **jaeger-agent** is logged, as well as every batch that is sent by **jaeger-agent** to **jaeger-collector**. **jaeger-collector** also logs every batch it receives and logs every span that is stored in the permanent storage. + +Here's what to expect when **jaeger-agent** is started with the `--log-level=debug` flag: + + {"level":"debug","ts":1544458854.5367086,"caller":"processors/thrift_processor.go:113","msg":"Span(s) received by the agent","bytes-received":359} + {"level":"debug","ts":1544458854.5408711,"caller":"tchannel/reporter.go:133","msg":"Span batch submitted by the agent","span-count":3} + +On the **jaeger-collector** side, these are the expected log entries when the flag `--log-level=debug` is specified: + + {"level":"debug","ts":1544458854.5406284,"caller":"app/span_handler.go:90","msg":"Span batch processed by the collector.","ok":true} + {"level":"debug","ts":1544458854.5406587,"caller":"app/span_processor.go:105","msg":"Span written to the storage by the collector","trace-id":"e66dc77b8a1e813b","span-id":"6b39b9c18f8ef082"} + {"level":"debug","ts":1544458854.54068,"caller":"app/span_processor.go:105","msg":"Span written to the storage by the collector","trace-id":"e66dc77b8a1e813b","span-id":"d92976b6055e6779"} + {"level":"debug","ts":1544458854.5406942,"caller":"app/span_processor.go:105","msg":"Span written to the storage by the collector","trace-id":"e66dc77b8a1e813b","span-id":"a56f41e38ca449a4"} + +## Check the /metrics endpoint + +For the cases where it's not possible or desirable to increase the logging on the **jaeger-collector** side, the `/metrics` endpoint can be used to check if spans for specific services are being received. The `/metrics` endpoint is served from the admin port, which is different for each binary (see [Deployment](../deployment/)). Assuming that **jaeger-collector** is available under a host named `jaeger-collector`, here's a sample `curl` call to obtain the metrics: + + curl http://jaeger-collector:14269/metrics + +The following metrics are of special interest: + + jaeger_collector_spans_received + jaeger_collector_spans_saved_by_svc + jaeger_collector_traces_received + jaeger_collector_traces_saved_by_svc + +The first two metrics should have similar values for the same service. Similarly, the two `traces` metrics should also have similar values. For instance, this is an example of a setup that is working as expected: + + jaeger_collector_spans_received{debug="false",format="jaeger",svc="order"} 8 + jaeger_collector_spans_saved_by_svc{debug="false",result="ok",svc="order"} 8 + jaeger_collector_traces_received{debug="false",format="jaeger",svc="order"} 1 + jaeger_collector_traces_saved_by_svc{debug="false",result="ok",svc="order"} 1 + +## Istio: missing spans + +When deploying your application as part of a service mesh like Istio, the number of moving parts increases significantly and might affect how (and which) spans are reported. If you expect to see spans generated by Istio but they aren't being visible in the Jaeger UI, check the troubleshooting guide on [Istio's website](https://istio.io/faq/distributed-tracing/#no-tracing). + +## Run debug images of the backend components + +We provide debug images for each Jaeger component. These images have [delve](https://github.com/go-delve/delve) and respective Jaeger component compiled with optimizations disabled. When you run these images, delve triggers the execution of the Jaeger component as its child process and immediately attaches to it to begin a new debug session and start listening on TCP port 12345 for remote connections. You can then use your IDEs like [Visual Studio Code](https://code.visualstudio.com/) or [GoLand](https://www.jetbrains.com/go/) to connect to this port and attach with it remotely and perform [debugging](https://golangforall.com/en/post/go-docker-delve-remote-debug.html) by adding breakpoints. + +For Visual Studio Code, you need to have the following configuration at the root of your local clone of the Jaeger source code: + + $ cat .vscode/launch.json + { + "version": "0.2.0", + "configurations": [ + { + "name": "Launch remote", + "type": "go", + "request": "attach", + "mode": "remote", + "remotePath": "", + "port": 12345, + "host": "127.0.0.1", + "cwd": "${workspaceRoot}", + } + ] + } diff --git a/content/docs/1.61/windows.md b/content/docs/1.61/windows.md new file mode 100644 index 00000000..8e8bbbf8 --- /dev/null +++ b/content/docs/1.61/windows.md @@ -0,0 +1,43 @@ +--- +title: Windows Service Deployment +hasparent: true +--- + +In Windows environments, Jaeger processes can be hosted and managed as Windows services controlled via the `sc` utility. To configure such services on Windows, download [nssm.exe](https://nssm.cc/download) for the appropriate architecture, and issue commands similar to how Jaeger is typically run. The example below showcases a basic Elasticsearch setup, configured using both environment variables and process arguments. + +## Agent +```bat +nssm install JaegerAgent C:\Jaeger\jaeger-agent.exe --reporter.grpc.host-port=localhost:14250 + +nssm set JaegerAgent AppStdout C:\Jaeger\jaeger-agent.out.log +nssm set JaegerAgent AppStderr C:\Jaeger\jaeger-agent.err.log +nssm set JaegerAgent Description Jaeger Agent service + +nssm start JaegerAgent +``` + +## Collector +```bat +nssm install JaegerCollector C:\Jaeger\jaeger-collector.exe --es.server-urls=http://localhost:9200 --es.username=jaeger --es.password=PASSWORD + +nssm set JaegerCollector AppStdout C:\Jaeger\jaeger-collector.out.log +nssm set JaegerCollector AppStderr C:\Jaeger\jaeger-collector.err.log +nssm set JaegerCollector Description Jaeger Collector service +nssm set JaegerCollector AppEnvironmentExtra SPAN_STORAGE_TYPE=elasticsearch + +nssm start JaegerCollector +``` + +## Query UI +```bat +nssm install JaegerUI C:\Jaeger\jaeger-query.exe --es.server-urls=http://localhost:9200 --es.username=jaeger --es.password=PASSWORD + +nssm set JaegerUI AppStdout C:\Jaeger\jaeger-ui.out.log +nssm set JaegerUI AppStderr C:\Jaeger\jaeger-ui.err.log +nssm set JaegerUI Description Jaeger Query service +nssm set JaegerUI AppEnvironmentExtra SPAN_STORAGE_TYPE=elasticsearch + +nssm start JaegerUI +``` + +For additional information & docs, please see [the NSSM usage guide.](https://nssm.cc/usage) \ No newline at end of file diff --git a/data/cli/1.61/config.json b/data/cli/1.61/config.json new file mode 100644 index 00000000..0205a094 --- /dev/null +++ b/data/cli/1.61/config.json @@ -0,0 +1,56 @@ +{ + "tools": [ + "jaeger-all-in-one", + "jaeger-agent", + "jaeger-collector", + "jaeger-ingester", + "jaeger-query" + ], + "jaeger-all-in-one": { + "storage": [ + "cassandra", + "elasticsearch", + "memory", + "badger" + ], + "sampling": [], + "metrics-storage": [ + "prometheus" + ] + }, + "jaeger-collector": { + "storage": [ + "cassandra", + "elasticsearch", + "kafka" + ], + "sampling": [ + "adaptive", + "file" + ], + "metrics-storage": [] + }, + "jaeger-ingester": { + "storage": [ + "cassandra", + "elasticsearch" + ], + "sampling": [], + "metrics-storage": [] + }, + "jaeger-query": { + "storage": [ + "cassandra", + "elasticsearch" + ], + "sampling": [], + "metrics-storage": [ + "prometheus" + ] + }, + "jaeger-agent": { + "storage": [], + "sampling": [], + "metrics-storage": [] + } +} diff --git a/data/cli/1.61/jaeger-agent.yaml b/data/cli/1.61/jaeger-agent.yaml new file mode 100644 index 00000000..c2300964 --- /dev/null +++ b/data/cli/1.61/jaeger-agent.yaml @@ -0,0 +1,143 @@ +name: jaeger-agent +synopsis: | + (deprecated) Jaeger agent is a local daemon program which collects tracing data. +description: | + (deprecated) Jaeger agent is a daemon program that runs on every host and receives tracing data submitted by Jaeger client libraries. +usage: jaeger-agent [flags] +options: + - name: admin.http.host-port + default_value: :14271 + usage: | + The host:port (e.g. 127.0.0.1:14271 or :14271) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: agent.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this agent. Ex: key1=value1,key2=${envVar:defaultValue} + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-agent + - name: http-server.host-port + default_value: :5778 + usage: | + host:port of the http server (e.g. for /sampling point and /baggageRestrictions endpoint) + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: processor.jaeger-binary.server-host-port + default_value: :6832 + usage: host:port for the UDP server + - name: processor.jaeger-binary.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-binary.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-binary.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-binary.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.jaeger-compact.server-host-port + default_value: :6831 + usage: host:port for the UDP server + - name: processor.jaeger-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.zipkin-compact.server-host-port + default_value: :5775 + usage: host:port for the UDP server + - name: processor.zipkin-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.zipkin-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.zipkin-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.zipkin-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: reporter.grpc.discovery.min-peers + default_value: "3" + usage: | + Max number of collectors to which the agent will try to connect at any given time + - name: reporter.grpc.host-port + usage: | + Comma-separated string representing host:port of a static list of collectors to connect to directly + - name: reporter.grpc.retry.max + default_value: "3" + usage: Sets the maximum number of retries for a call + - name: reporter.grpc.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: reporter.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: reporter.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: reporter.grpc.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: reporter.type + default_value: grpc + usage: Reporter type to use e.g. grpc +see_also: + - jaeger-agent completion - Generate the autocompletion script for the specified shell + - jaeger-agent docs - Generates documentation + - jaeger-agent status - Print the status. + - jaeger-agent version - Print the version. diff --git a/data/cli/1.61/jaeger-agent_completion.yaml b/data/cli/1.61/jaeger-agent_completion.yaml new file mode 100644 index 00000000..3e599d75 --- /dev/null +++ b/data/cli/1.61/jaeger-agent_completion.yaml @@ -0,0 +1,16 @@ +name: jaeger-agent completion +synopsis: Generate the autocompletion script for the specified shell +description: | + Generate the autocompletion script for jaeger-agent for the specified shell. + See each sub-command's help for details on how to use the generated script. +options: + - name: help + shorthand: h + default_value: "false" + usage: help for completion +see_also: + - jaeger-agent - (deprecated) Jaeger agent is a local daemon program which collects tracing data. + - jaeger-agent completion bash - Generate the autocompletion script for bash + - jaeger-agent completion fish - Generate the autocompletion script for fish + - jaeger-agent completion powershell - Generate the autocompletion script for powershell + - jaeger-agent completion zsh - Generate the autocompletion script for zsh diff --git a/data/cli/1.61/jaeger-agent_docs.yaml b/data/cli/1.61/jaeger-agent_docs.yaml new file mode 100644 index 00000000..8ef47d05 --- /dev/null +++ b/data/cli/1.61/jaeger-agent_docs.yaml @@ -0,0 +1,17 @@ +name: jaeger-agent docs +synopsis: Generates documentation +description: Generates command and flags documentation +usage: jaeger-agent docs [flags] +options: + - name: dir + default_value: ./ + usage: Directory where generate the documentation. + - name: format + default_value: md + usage: 'Supported formats: [md man rst yaml].' + - name: help + shorthand: h + default_value: "false" + usage: help for docs +see_also: + - jaeger-agent - (deprecated) Jaeger agent is a local daemon program which collects tracing data. diff --git a/data/cli/1.61/jaeger-agent_status.yaml b/data/cli/1.61/jaeger-agent_status.yaml new file mode 100644 index 00000000..83ce3f2c --- /dev/null +++ b/data/cli/1.61/jaeger-agent_status.yaml @@ -0,0 +1,16 @@ +name: jaeger-agent status +synopsis: Print the status. +description: | + Print Jaeger component status information, exit non-zero on any error. +usage: jaeger-agent status [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for status + - name: status.http.host-port + default_value: :14271 + usage: | + The host:port (e.g. 127.0.0.1:14271 or :14271) for the health check +see_also: + - jaeger-agent - (deprecated) Jaeger agent is a local daemon program which collects tracing data. diff --git a/data/cli/1.61/jaeger-agent_version.yaml b/data/cli/1.61/jaeger-agent_version.yaml new file mode 100644 index 00000000..f967754c --- /dev/null +++ b/data/cli/1.61/jaeger-agent_version.yaml @@ -0,0 +1,11 @@ +name: jaeger-agent version +synopsis: Print the version. +description: Print the version and build information. +usage: jaeger-agent version [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for version +see_also: + - jaeger-agent - (deprecated) Jaeger agent is a local daemon program which collects tracing data. diff --git a/data/cli/1.61/jaeger-all-in-one-badger.yaml b/data/cli/1.61/jaeger-all-in-one-badger.yaml new file mode 100644 index 00000000..733ba55b --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one-badger.yaml @@ -0,0 +1,490 @@ +name: jaeger-all-in-one +synopsis: | + Jaeger all-in-one distribution with agent, collector and query in one process. +description: |- + Jaeger all-in-one distribution with agent, collector and query. Use with caution this version + by default uses only in-memory database. +usage: jaeger-all-in-one [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: badger.consistency + default_value: "false" + usage: | + If all writes should be synced immediately to physical disk. This will impact write performance. + - name: badger.directory-key + default_value: /go/bin/data/keys + usage: | + Path to store the keys (indexes), this directory should reside in SSD disk. Set ephemeral to false if you want to define this setting. + - name: badger.directory-value + default_value: /go/bin/data/values + usage: | + Path to store the values (spans). Set ephemeral to false if you want to define this setting. + - name: badger.ephemeral + default_value: "true" + usage: Mark this storage ephemeral, data is stored in tmpfs. + - name: badger.maintenance-interval + default_value: 5m0s + usage: | + How often the maintenance thread for values is ran. Format is time.Duration (https://golang.org/pkg/time/#Duration) + - name: badger.metrics-update-interval + default_value: 10s + usage: | + How often the badger metrics are collected by Jaeger. Format is time.Duration (https://golang.org/pkg/time/#Duration) + - name: badger.read-only + default_value: "false" + usage: | + Allows to open badger database in read only mode. Multiple instances can open same database in read-only mode. Values still in the write-ahead-log must be replayed before opening. + - name: badger.span-store-ttl + default_value: 72h0m0s + usage: | + How long to store the data. Format is time.Duration (https://golang.org/pkg/time/#Duration) + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-all-in-one + - name: http-server.host-port + default_value: :5778 + usage: | + host:port of the http server (e.g. for /sampling point and /baggageRestrictions endpoint) + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: processor.jaeger-binary.server-host-port + default_value: :6832 + usage: host:port for the UDP server + - name: processor.jaeger-binary.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-binary.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-binary.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-binary.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.jaeger-compact.server-host-port + default_value: :6831 + usage: host:port for the UDP server + - name: processor.jaeger-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.zipkin-compact.server-host-port + default_value: :5775 + usage: host:port for the UDP server + - name: processor.zipkin-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.zipkin-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.zipkin-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.zipkin-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: reporter.grpc.discovery.min-peers + default_value: "3" + usage: | + Max number of collectors to which the agent will try to connect at any given time + - name: reporter.grpc.host-port + usage: | + Comma-separated string representing host:port of a static list of collectors to connect to directly + - name: reporter.grpc.retry.max + default_value: "3" + usage: Sets the maximum number of retries for a call + - name: reporter.grpc.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: reporter.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: reporter.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: reporter.grpc.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: reporter.type + default_value: grpc + usage: Reporter type to use e.g. grpc + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-all-in-one completion - Generate the autocompletion script for the specified shell + - jaeger-all-in-one docs - Generates documentation + - jaeger-all-in-one env - Help about environment variables. + - jaeger-all-in-one print-config - Print names and values of configuration options + - jaeger-all-in-one status - Print the status. + - jaeger-all-in-one version - Print the version. diff --git a/data/cli/1.61/jaeger-all-in-one-cassandra.yaml b/data/cli/1.61/jaeger-all-in-one-cassandra.yaml new file mode 100644 index 00000000..85199fcf --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one-cassandra.yaml @@ -0,0 +1,613 @@ +name: jaeger-all-in-one +synopsis: | + Jaeger all-in-one distribution with agent, collector and query in one process. +description: |- + Jaeger all-in-one distribution with agent, collector and query. Use with caution this version + by default uses only in-memory database. +usage: jaeger-all-in-one [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-all-in-one + - name: http-server.host-port + default_value: :5778 + usage: | + host:port of the http server (e.g. for /sampling point and /baggageRestrictions endpoint) + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: processor.jaeger-binary.server-host-port + default_value: :6832 + usage: host:port for the UDP server + - name: processor.jaeger-binary.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-binary.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-binary.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-binary.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.jaeger-compact.server-host-port + default_value: :6831 + usage: host:port for the UDP server + - name: processor.jaeger-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.zipkin-compact.server-host-port + default_value: :5775 + usage: host:port for the UDP server + - name: processor.zipkin-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.zipkin-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.zipkin-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.zipkin-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: reporter.grpc.discovery.min-peers + default_value: "3" + usage: | + Max number of collectors to which the agent will try to connect at any given time + - name: reporter.grpc.host-port + usage: | + Comma-separated string representing host:port of a static list of collectors to connect to directly + - name: reporter.grpc.retry.max + default_value: "3" + usage: Sets the maximum number of retries for a call + - name: reporter.grpc.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: reporter.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: reporter.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: reporter.grpc.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: reporter.type + default_value: grpc + usage: Reporter type to use e.g. grpc + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-all-in-one completion - Generate the autocompletion script for the specified shell + - jaeger-all-in-one docs - Generates documentation + - jaeger-all-in-one env - Help about environment variables. + - jaeger-all-in-one print-config - Print names and values of configuration options + - jaeger-all-in-one status - Print the status. + - jaeger-all-in-one version - Print the version. diff --git a/data/cli/1.61/jaeger-all-in-one-elasticsearch.yaml b/data/cli/1.61/jaeger-all-in-one-elasticsearch.yaml new file mode 100644 index 00000000..14e11ec4 --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one-elasticsearch.yaml @@ -0,0 +1,755 @@ +name: jaeger-all-in-one +synopsis: | + Jaeger all-in-one distribution with agent, collector and query in one process. +description: |- + Jaeger all-in-one distribution with agent, collector and query. Use with caution this version + by default uses only in-memory database. +usage: jaeger-all-in-one [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: es-archive.adaptive-sampling.lookback + default_value: 72h0m0s + usage: | + How far back to look for the latest adaptive sampling probabilities + - name: es-archive.bulk.actions + default_value: "1000" + usage: | + The number of requests that can be enqueued before the bulk processor decides to commit + - name: es-archive.bulk.flush-interval + default_value: 200ms + usage: | + A time.Duration after which bulk requests are committed, regardless of other thresholds. Set to zero to disable. By default, this is disabled. + - name: es-archive.bulk.size + default_value: "5000000" + usage: | + The number of bytes that the bulk requests can take up before the bulk processor decides to commit + - name: es-archive.bulk.workers + default_value: "1" + usage: | + The number of workers that are able to receive bulk requests and eventually commit them to Elasticsearch + - name: es-archive.create-index-templates + default_value: "true" + usage: | + Create index templates at application startup. Set to false when templates are installed manually. + - name: es-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: es-archive.index-date-separator + default_value: '-' + usage: | + Optional date separator of Jaeger indices. For example "." creates "jaeger-span-2020.11.20". + - name: es-archive.index-prefix + usage: | + Optional prefix of Jaeger indices. For example "production" creates "production-jaeger-*". + - name: es-archive.index-rollover-frequency-adaptive-sampling + default_value: day + usage: | + Rotates jaeger-sampling indices over the given period. For example "day" creates "jaeger-sampling-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.index-rollover-frequency-services + default_value: day + usage: | + Rotates jaeger-service indices over the given period. For example "day" creates "jaeger-service-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.index-rollover-frequency-spans + default_value: day + usage: | + Rotates jaeger-span indices over the given period. For example "day" creates "jaeger-span-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.log-level + default_value: error + usage: | + The Elasticsearch client log-level. Valid levels: [debug, info, error] + - name: es-archive.max-doc-count + default_value: "10000" + usage: | + The maximum document count to return from an Elasticsearch query. This will also apply to aggregations. + - name: es-archive.num-replicas + default_value: "1" + usage: The number of replicas per index in Elasticsearch + - name: es-archive.num-shards + default_value: "5" + usage: The number of shards per index in Elasticsearch + - name: es-archive.password + usage: The password required by Elasticsearch + - name: es-archive.password-file + usage: | + Path to a file containing password. This file is watched for changes. + - name: es-archive.prioirity-dependencies-template + default_value: "0" + usage: Priority of jaeger-dependecies index template (ESv8 only) + - name: es-archive.prioirity-service-template + default_value: "0" + usage: Priority of jaeger-service index template (ESv8 only) + - name: es-archive.prioirity-span-template + default_value: "0" + usage: Priority of jaeger-span index template (ESv8 only) + - name: es-archive.remote-read-clusters + usage: | + Comma-separated list of Elasticsearch remote cluster names for cross-cluster querying.See Elasticsearch remote clusters and cross-cluster query api. + - name: es-archive.send-get-body-as + usage: HTTP verb for requests that contain a body [GET, POST]. + - name: es-archive.server-urls + default_value: http://127.0.0.1:9200 + usage: | + The comma-separated list of Elasticsearch servers, must be full url i.e. http://localhost:9200 + - name: es-archive.service-cache-ttl + default_value: 0s + usage: The TTL for the cache of known service names + - name: es-archive.sniffer + default_value: "false" + usage: | + The sniffer config for Elasticsearch; client uses sniffing process to find all nodes automatically, disable if not required + - name: es-archive.sniffer-tls-enabled + default_value: "false" + usage: | + Option to enable TLS when sniffing an Elasticsearch Cluster ; client uses sniffing process to find all nodes automatically, disabled by default + - name: es-archive.tags-as-fields.all + default_value: "false" + usage: | + (experimental) Store all span and process tags as object fields. If true .tags-as-fields.config-file and .tags-as-fields.include is ignored. Binary tags are always stored as nested objects. + - name: es-archive.tags-as-fields.config-file + usage: | + (experimental) Optional path to a file containing tag keys which will be stored as object fields. Each key should be on a separate line. Merged with .tags-as-fields.include + - name: es-archive.tags-as-fields.dot-replacement + default_value: '@' + usage: | + (experimental) The character used to replace dots (".") in tag keys stored as object fields. + - name: es-archive.tags-as-fields.include + usage: | + (experimental) Comma delimited list of tag keys which will be stored as object fields. Merged with the contents of .tags-as-fields.config-file + - name: es-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: es-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: es-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: es-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: es-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: es-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: es-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: es-archive.token-file + usage: | + Path to a file containing bearer token. This flag also loads CA if it is specified. + - name: es-archive.use-aliases + default_value: "false" + usage: | + Use read and write aliases for indices. Use this option with Elasticsearch rollover API. It requires an external component to create aliases before startup and then performing its management. Note that es.max-span-age will influence trace search window start times. + - name: es-archive.use-ilm + default_value: "false" + usage: | + (experimental) Option to enable ILM for jaeger span & service indices. Use this option with es-archive.use-aliases. It requires an external component to create aliases before startup and then performing its management. ILM policy must be manually created in ES before startup. Supported only for elasticsearch version 7+. + - name: es-archive.username + usage: | + The username required by Elasticsearch. The basic authentication also loads CA if it is specified. + - name: es-archive.version + default_value: "0" + usage: | + The major Elasticsearch version. If not specified, the value will be auto-detected from Elasticsearch. + - name: es.adaptive-sampling.lookback + default_value: 72h0m0s + usage: | + How far back to look for the latest adaptive sampling probabilities + - name: es.bulk.actions + default_value: "1000" + usage: | + The number of requests that can be enqueued before the bulk processor decides to commit + - name: es.bulk.flush-interval + default_value: 200ms + usage: | + A time.Duration after which bulk requests are committed, regardless of other thresholds. Set to zero to disable. By default, this is disabled. + - name: es.bulk.size + default_value: "5000000" + usage: | + The number of bytes that the bulk requests can take up before the bulk processor decides to commit + - name: es.bulk.workers + default_value: "1" + usage: | + The number of workers that are able to receive bulk requests and eventually commit them to Elasticsearch + - name: es.create-index-templates + default_value: "true" + usage: | + Create index templates at application startup. Set to false when templates are installed manually. + - name: es.index-date-separator + default_value: '-' + usage: | + Optional date separator of Jaeger indices. For example "." creates "jaeger-span-2020.11.20". + - name: es.index-prefix + usage: | + Optional prefix of Jaeger indices. For example "production" creates "production-jaeger-*". + - name: es.index-rollover-frequency-adaptive-sampling + default_value: day + usage: | + Rotates jaeger-sampling indices over the given period. For example "day" creates "jaeger-sampling-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.index-rollover-frequency-services + default_value: day + usage: | + Rotates jaeger-service indices over the given period. For example "day" creates "jaeger-service-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.index-rollover-frequency-spans + default_value: day + usage: | + Rotates jaeger-span indices over the given period. For example "day" creates "jaeger-span-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.log-level + default_value: error + usage: | + The Elasticsearch client log-level. Valid levels: [debug, info, error] + - name: es.max-doc-count + default_value: "10000" + usage: | + The maximum document count to return from an Elasticsearch query. This will also apply to aggregations. + - name: es.max-span-age + default_value: 72h0m0s + usage: The maximum lookback for spans in Elasticsearch + - name: es.num-replicas + default_value: "1" + usage: The number of replicas per index in Elasticsearch + - name: es.num-shards + default_value: "5" + usage: The number of shards per index in Elasticsearch + - name: es.password + usage: The password required by Elasticsearch + - name: es.password-file + usage: | + Path to a file containing password. This file is watched for changes. + - name: es.prioirity-dependencies-template + default_value: "0" + usage: Priority of jaeger-dependecies index template (ESv8 only) + - name: es.prioirity-service-template + default_value: "0" + usage: Priority of jaeger-service index template (ESv8 only) + - name: es.prioirity-span-template + default_value: "0" + usage: Priority of jaeger-span index template (ESv8 only) + - name: es.remote-read-clusters + usage: | + Comma-separated list of Elasticsearch remote cluster names for cross-cluster querying.See Elasticsearch remote clusters and cross-cluster query api. + - name: es.send-get-body-as + usage: HTTP verb for requests that contain a body [GET, POST]. + - name: es.server-urls + default_value: http://127.0.0.1:9200 + usage: | + The comma-separated list of Elasticsearch servers, must be full url i.e. http://localhost:9200 + - name: es.service-cache-ttl + default_value: 0s + usage: The TTL for the cache of known service names + - name: es.sniffer + default_value: "false" + usage: | + The sniffer config for Elasticsearch; client uses sniffing process to find all nodes automatically, disable if not required + - name: es.sniffer-tls-enabled + default_value: "false" + usage: | + Option to enable TLS when sniffing an Elasticsearch Cluster ; client uses sniffing process to find all nodes automatically, disabled by default + - name: es.tags-as-fields.all + default_value: "false" + usage: | + (experimental) Store all span and process tags as object fields. If true .tags-as-fields.config-file and .tags-as-fields.include is ignored. Binary tags are always stored as nested objects. + - name: es.tags-as-fields.config-file + usage: | + (experimental) Optional path to a file containing tag keys which will be stored as object fields. Each key should be on a separate line. Merged with .tags-as-fields.include + - name: es.tags-as-fields.dot-replacement + default_value: '@' + usage: | + (experimental) The character used to replace dots (".") in tag keys stored as object fields. + - name: es.tags-as-fields.include + usage: | + (experimental) Comma delimited list of tag keys which will be stored as object fields. Merged with the contents of .tags-as-fields.config-file + - name: es.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: es.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: es.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: es.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: es.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: es.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: es.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: es.token-file + usage: | + Path to a file containing bearer token. This flag also loads CA if it is specified. + - name: es.use-aliases + default_value: "false" + usage: | + Use read and write aliases for indices. Use this option with Elasticsearch rollover API. It requires an external component to create aliases before startup and then performing its management. Note that es.max-span-age will influence trace search window start times. + - name: es.use-ilm + default_value: "false" + usage: | + (experimental) Option to enable ILM for jaeger span & service indices. Use this option with es.use-aliases. It requires an external component to create aliases before startup and then performing its management. ILM policy must be manually created in ES before startup. Supported only for elasticsearch version 7+. + - name: es.username + usage: | + The username required by Elasticsearch. The basic authentication also loads CA if it is specified. + - name: es.version + default_value: "0" + usage: | + The major Elasticsearch version. If not specified, the value will be auto-detected from Elasticsearch. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-all-in-one + - name: http-server.host-port + default_value: :5778 + usage: | + host:port of the http server (e.g. for /sampling point and /baggageRestrictions endpoint) + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: processor.jaeger-binary.server-host-port + default_value: :6832 + usage: host:port for the UDP server + - name: processor.jaeger-binary.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-binary.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-binary.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-binary.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.jaeger-compact.server-host-port + default_value: :6831 + usage: host:port for the UDP server + - name: processor.jaeger-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.zipkin-compact.server-host-port + default_value: :5775 + usage: host:port for the UDP server + - name: processor.zipkin-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.zipkin-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.zipkin-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.zipkin-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: reporter.grpc.discovery.min-peers + default_value: "3" + usage: | + Max number of collectors to which the agent will try to connect at any given time + - name: reporter.grpc.host-port + usage: | + Comma-separated string representing host:port of a static list of collectors to connect to directly + - name: reporter.grpc.retry.max + default_value: "3" + usage: Sets the maximum number of retries for a call + - name: reporter.grpc.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: reporter.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: reporter.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: reporter.grpc.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: reporter.type + default_value: grpc + usage: Reporter type to use e.g. grpc + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-all-in-one completion - Generate the autocompletion script for the specified shell + - jaeger-all-in-one docs - Generates documentation + - jaeger-all-in-one env - Help about environment variables. + - jaeger-all-in-one print-config - Print names and values of configuration options + - jaeger-all-in-one status - Print the status. + - jaeger-all-in-one version - Print the version. diff --git a/data/cli/1.61/jaeger-all-in-one-memory.yaml b/data/cli/1.61/jaeger-all-in-one-memory.yaml new file mode 100644 index 00000000..2cd894ee --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one-memory.yaml @@ -0,0 +1,463 @@ +name: jaeger-all-in-one +synopsis: | + Jaeger all-in-one distribution with agent, collector and query in one process. +description: |- + Jaeger all-in-one distribution with agent, collector and query. Use with caution this version + by default uses only in-memory database. +usage: jaeger-all-in-one [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-all-in-one + - name: http-server.host-port + default_value: :5778 + usage: | + host:port of the http server (e.g. for /sampling point and /baggageRestrictions endpoint) + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: memory.max-traces + default_value: "0" + usage: | + The maximum amount of traces to store in memory. The default number of traces is unbounded. + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: processor.jaeger-binary.server-host-port + default_value: :6832 + usage: host:port for the UDP server + - name: processor.jaeger-binary.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-binary.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-binary.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-binary.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.jaeger-compact.server-host-port + default_value: :6831 + usage: host:port for the UDP server + - name: processor.jaeger-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.zipkin-compact.server-host-port + default_value: :5775 + usage: host:port for the UDP server + - name: processor.zipkin-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.zipkin-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.zipkin-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.zipkin-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: reporter.grpc.discovery.min-peers + default_value: "3" + usage: | + Max number of collectors to which the agent will try to connect at any given time + - name: reporter.grpc.host-port + usage: | + Comma-separated string representing host:port of a static list of collectors to connect to directly + - name: reporter.grpc.retry.max + default_value: "3" + usage: Sets the maximum number of retries for a call + - name: reporter.grpc.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: reporter.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: reporter.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: reporter.grpc.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: reporter.type + default_value: grpc + usage: Reporter type to use e.g. grpc + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-all-in-one completion - Generate the autocompletion script for the specified shell + - jaeger-all-in-one docs - Generates documentation + - jaeger-all-in-one env - Help about environment variables. + - jaeger-all-in-one print-config - Print names and values of configuration options + - jaeger-all-in-one status - Print the status. + - jaeger-all-in-one version - Print the version. diff --git a/data/cli/1.61/jaeger-all-in-one-prometheus.yaml b/data/cli/1.61/jaeger-all-in-one-prometheus.yaml new file mode 100644 index 00000000..45b303c3 --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one-prometheus.yaml @@ -0,0 +1,511 @@ +name: jaeger-all-in-one +synopsis: | + Jaeger all-in-one distribution with agent, collector and query in one process. +description: |- + Jaeger all-in-one distribution with agent, collector and query. Use with caution this version + by default uses only in-memory database. +usage: jaeger-all-in-one [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-all-in-one + - name: http-server.host-port + default_value: :5778 + usage: | + host:port of the http server (e.g. for /sampling point and /baggageRestrictions endpoint) + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: memory.max-traces + default_value: "0" + usage: | + The maximum amount of traces to store in memory. The default number of traces is unbounded. + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: processor.jaeger-binary.server-host-port + default_value: :6832 + usage: host:port for the UDP server + - name: processor.jaeger-binary.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-binary.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-binary.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-binary.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.jaeger-compact.server-host-port + default_value: :6831 + usage: host:port for the UDP server + - name: processor.jaeger-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.zipkin-compact.server-host-port + default_value: :5775 + usage: host:port for the UDP server + - name: processor.zipkin-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.zipkin-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.zipkin-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.zipkin-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: prometheus.connect-timeout + default_value: 30s + usage: | + The period to wait for a connection to Prometheus when executing queries. + - name: prometheus.query.duration-unit + default_value: ms + usage: | + The units used for the "latency" histogram. It can be either "ms" or "s" and should be consistent with the histogram unit value set in the spanmetrics connector (see: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/connector/spanmetricsconnector#configurations). This also helps jaeger-query determine the metric name when querying for "latency" metrics. + - name: prometheus.query.namespace + usage: | + The metric namespace that is prefixed to the metric name. A '.' separator will be added between the namespace and the metric name. + - name: prometheus.query.normalize-calls + default_value: "false" + usage: "Whether to normalize the \"calls\" metric name according to https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/pkg/translator/prometheus/README.md. For example: \"calls\" (not normalized) -> \"calls_total\" (normalized), \n" + - name: prometheus.query.normalize-duration + default_value: "false" + usage: | + Whether to normalize the "duration" metric name according to https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/pkg/translator/prometheus/README.md. For example: "duration_bucket" (not normalized) -> "duration_milliseconds_bucket (normalized)" + - name: prometheus.server-url + default_value: http://localhost:9090 + usage: | + The Prometheus server's URL, must include the protocol scheme e.g. http://localhost:9090 + - name: prometheus.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: prometheus.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: prometheus.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: prometheus.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: prometheus.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: prometheus.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: prometheus.token-file + usage: | + The path to a file containing the bearer token which will be included when executing queries against the Prometheus API. + - name: prometheus.token-override-from-context + default_value: "true" + usage: | + Whether the bearer token should be overridden from context (incoming request) + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: reporter.grpc.discovery.min-peers + default_value: "3" + usage: | + Max number of collectors to which the agent will try to connect at any given time + - name: reporter.grpc.host-port + usage: | + Comma-separated string representing host:port of a static list of collectors to connect to directly + - name: reporter.grpc.retry.max + default_value: "3" + usage: Sets the maximum number of retries for a call + - name: reporter.grpc.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: reporter.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: reporter.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: reporter.grpc.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: reporter.type + default_value: grpc + usage: Reporter type to use e.g. grpc + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-all-in-one completion - Generate the autocompletion script for the specified shell + - jaeger-all-in-one docs - Generates documentation + - jaeger-all-in-one env - Help about environment variables. + - jaeger-all-in-one print-config - Print names and values of configuration options + - jaeger-all-in-one status - Print the status. + - jaeger-all-in-one version - Print the version. diff --git a/data/cli/1.61/jaeger-all-in-one.yaml b/data/cli/1.61/jaeger-all-in-one.yaml new file mode 100644 index 00000000..2cd894ee --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one.yaml @@ -0,0 +1,463 @@ +name: jaeger-all-in-one +synopsis: | + Jaeger all-in-one distribution with agent, collector and query in one process. +description: |- + Jaeger all-in-one distribution with agent, collector and query. Use with caution this version + by default uses only in-memory database. +usage: jaeger-all-in-one [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-all-in-one + - name: http-server.host-port + default_value: :5778 + usage: | + host:port of the http server (e.g. for /sampling point and /baggageRestrictions endpoint) + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: memory.max-traces + default_value: "0" + usage: | + The maximum amount of traces to store in memory. The default number of traces is unbounded. + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: processor.jaeger-binary.server-host-port + default_value: :6832 + usage: host:port for the UDP server + - name: processor.jaeger-binary.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-binary.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-binary.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-binary.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.jaeger-compact.server-host-port + default_value: :6831 + usage: host:port for the UDP server + - name: processor.jaeger-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.jaeger-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.jaeger-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.jaeger-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: processor.zipkin-compact.server-host-port + default_value: :5775 + usage: host:port for the UDP server + - name: processor.zipkin-compact.server-max-packet-size + default_value: "65000" + usage: max packet size for the UDP server + - name: processor.zipkin-compact.server-queue-size + default_value: "1000" + usage: length of the queue for the UDP server + - name: processor.zipkin-compact.server-socket-buffer-size + default_value: "0" + usage: socket buffer size for UDP packets in bytes + - name: processor.zipkin-compact.workers + default_value: "10" + usage: how many workers the processor should run + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: reporter.grpc.discovery.min-peers + default_value: "3" + usage: | + Max number of collectors to which the agent will try to connect at any given time + - name: reporter.grpc.host-port + usage: | + Comma-separated string representing host:port of a static list of collectors to connect to directly + - name: reporter.grpc.retry.max + default_value: "3" + usage: Sets the maximum number of retries for a call + - name: reporter.grpc.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: reporter.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: reporter.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: reporter.grpc.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: reporter.grpc.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: reporter.type + default_value: grpc + usage: Reporter type to use e.g. grpc + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-all-in-one completion - Generate the autocompletion script for the specified shell + - jaeger-all-in-one docs - Generates documentation + - jaeger-all-in-one env - Help about environment variables. + - jaeger-all-in-one print-config - Print names and values of configuration options + - jaeger-all-in-one status - Print the status. + - jaeger-all-in-one version - Print the version. diff --git a/data/cli/1.61/jaeger-all-in-one_completion.yaml b/data/cli/1.61/jaeger-all-in-one_completion.yaml new file mode 100644 index 00000000..746ab7eb --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one_completion.yaml @@ -0,0 +1,16 @@ +name: jaeger-all-in-one completion +synopsis: Generate the autocompletion script for the specified shell +description: | + Generate the autocompletion script for jaeger-all-in-one for the specified shell. + See each sub-command's help for details on how to use the generated script. +options: + - name: help + shorthand: h + default_value: "false" + usage: help for completion +see_also: + - jaeger-all-in-one - Jaeger all-in-one distribution with agent, collector and query in one process. + - jaeger-all-in-one completion bash - Generate the autocompletion script for bash + - jaeger-all-in-one completion fish - Generate the autocompletion script for fish + - jaeger-all-in-one completion powershell - Generate the autocompletion script for powershell + - jaeger-all-in-one completion zsh - Generate the autocompletion script for zsh diff --git a/data/cli/1.61/jaeger-all-in-one_docs.yaml b/data/cli/1.61/jaeger-all-in-one_docs.yaml new file mode 100644 index 00000000..4fa495d4 --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one_docs.yaml @@ -0,0 +1,17 @@ +name: jaeger-all-in-one docs +synopsis: Generates documentation +description: Generates command and flags documentation +usage: jaeger-all-in-one docs [flags] +options: + - name: dir + default_value: ./ + usage: Directory where generate the documentation. + - name: format + default_value: md + usage: 'Supported formats: [md man rst yaml].' + - name: help + shorthand: h + default_value: "false" + usage: help for docs +see_also: + - jaeger-all-in-one - Jaeger all-in-one distribution with agent, collector and query in one process. diff --git a/data/cli/1.61/jaeger-all-in-one_env.yaml b/data/cli/1.61/jaeger-all-in-one_env.yaml new file mode 100644 index 00000000..af796966 --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one_env.yaml @@ -0,0 +1,11 @@ +name: jaeger-all-in-one env +synopsis: Help about environment variables. +description: "\nAll command line options can be provided via environment variables by converting\ntheir names to upper case and replacing punctuation with underscores. For example:\n\ncommand line option environment variable\n------------------------------------------------------------------\n--cassandra.connections-per-host CASSANDRA_CONNECTIONS_PER_HOST\n--metrics-backend METRICS_BACKEND\n\nThe following configuration options are only available via environment variables:\n\nSPAN_STORAGE_TYPE string The type of backend [cassandra, opensearch, elasticsearch, memory, kafka, badger, blackhole, grpc] used for trace storage. Multiple backends can be specified as comma-separated list, e.g. \"cassandra,elasticsearch\" (currently only for writing spans). Note that \"kafka\" is only valid in jaeger-collector; it is not a replacement for a proper storage backend, and only used as a buffer for spans when Jaeger is deployed in the collector+ingester configuration. (default \"cassandra\")\n\nDEPENDENCY_STORAGE_TYPE string The type of backend used for service dependencies storage. (default \"${SPAN_STORAGE_TYPE}\")\n\nSAMPLING_CONFIG_TYPE string The method [file, adaptive] used for determining the sampling rates served to clients configured with remote sampling enabled. \"file\" uses a periodically reloaded file and \"adaptive\" dynamically adjusts sampling rates based on current traffic. (default \"file\")\n\nSAMPLING_STORAGE_TYPE string The type of backend [cassandra, memory, badger] used for adaptive sampling storage when adaptive sampling is enabled via SAMPLING_CONFIG_TYPE. \n\nMETRICS_STORAGE_TYPE string The type of backend [prometheus] used as a metrics store with Service Performance Monitoring (https://www.jaegertracing.io/docs/latest/spm/). \n\n" +usage: jaeger-all-in-one env [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for env +see_also: + - jaeger-all-in-one - Jaeger all-in-one distribution with agent, collector and query in one process. diff --git a/data/cli/1.61/jaeger-all-in-one_print-config.yaml b/data/cli/1.61/jaeger-all-in-one_print-config.yaml new file mode 100644 index 00000000..21c45e87 --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one_print-config.yaml @@ -0,0 +1,17 @@ +name: jaeger-all-in-one print-config +synopsis: Print names and values of configuration options +description: | + Print names and values of configuration options, distinguishing between default and user-assigned values +usage: jaeger-all-in-one print-config [flags] +options: + - name: all + shorthand: a + default_value: "false" + usage: | + Print all configuration options including those with empty values + - name: help + shorthand: h + default_value: "false" + usage: help for print-config +see_also: + - jaeger-all-in-one - Jaeger all-in-one distribution with agent, collector and query in one process. diff --git a/data/cli/1.61/jaeger-all-in-one_status.yaml b/data/cli/1.61/jaeger-all-in-one_status.yaml new file mode 100644 index 00000000..0f948114 --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one_status.yaml @@ -0,0 +1,16 @@ +name: jaeger-all-in-one status +synopsis: Print the status. +description: | + Print Jaeger component status information, exit non-zero on any error. +usage: jaeger-all-in-one status [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for status + - name: status.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the health check +see_also: + - jaeger-all-in-one - Jaeger all-in-one distribution with agent, collector and query in one process. diff --git a/data/cli/1.61/jaeger-all-in-one_version.yaml b/data/cli/1.61/jaeger-all-in-one_version.yaml new file mode 100644 index 00000000..0b031a5f --- /dev/null +++ b/data/cli/1.61/jaeger-all-in-one_version.yaml @@ -0,0 +1,11 @@ +name: jaeger-all-in-one version +synopsis: Print the version. +description: Print the version and build information. +usage: jaeger-all-in-one version [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for version +see_also: + - jaeger-all-in-one - Jaeger all-in-one distribution with agent, collector and query in one process. diff --git a/data/cli/1.61/jaeger-collector-adaptive.yaml b/data/cli/1.61/jaeger-collector-adaptive.yaml new file mode 100644 index 00000000..bb76785c --- /dev/null +++ b/data/cli/1.61/jaeger-collector-adaptive.yaml @@ -0,0 +1,482 @@ +name: jaeger-collector +synopsis: | + Jaeger collector receives and processes traces from Jaeger agents and clients +description: | + Jaeger collector receives traces from Jaeger agents and runs them through a processing pipeline. +usage: jaeger-collector [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-collector + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: sampling.aggregation-buckets + default_value: "10" + usage: Amount of historical data to keep in memory. + - name: sampling.buckets-for-calculation + default_value: "1" + usage: | + This determines how much of the previous data is used in calculating the weighted QPS, ie. if BucketsForCalculation is 1, only the most recent data will be used in calculating the weighted QPS. + - name: sampling.calculation-interval + default_value: 1m0s + usage: | + How often new sampling probabilities are calculated. Recommended to be greater than the polling interval of your clients. + - name: sampling.delay + default_value: 2m0s + usage: | + Determines how far back the most recent state is. Use this if you want to add some buffer time for the aggregation to finish. + - name: sampling.delta-tolerance + default_value: "0.3" + usage: | + The acceptable amount of deviation between the observed samples-per-second and the desired (target) samples-per-second, expressed as a ratio. + - name: sampling.follower-lease-refresh-interval + default_value: 1m0s + usage: The duration to sleep if this processor is a follower. + - name: sampling.initial-sampling-probability + default_value: "0.001" + usage: The initial sampling probability for all new operations. + - name: sampling.leader-lease-refresh-interval + default_value: 5s + usage: | + The duration to sleep if this processor is elected leader before attempting to renew the lease on the leader lock. This should be less than follower-lease-refresh-interval to reduce lock thrashing. + - name: sampling.min-samples-per-second + default_value: "0.016666666666666666" + usage: The minimum number of traces that are sampled per second. + - name: sampling.min-sampling-probability + default_value: "1e-05" + usage: The minimum sampling probability for all operations. + - name: sampling.target-samples-per-second + default_value: "1" + usage: The global target rate of samples per operation. + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-collector completion - Generate the autocompletion script for the specified shell + - jaeger-collector docs - Generates documentation + - jaeger-collector env - Help about environment variables. + - jaeger-collector print-config - Print names and values of configuration options + - jaeger-collector status - Print the status. + - jaeger-collector version - Print the version. diff --git a/data/cli/1.61/jaeger-collector-cassandra.yaml b/data/cli/1.61/jaeger-collector-cassandra.yaml new file mode 100644 index 00000000..0a27a121 --- /dev/null +++ b/data/cli/1.61/jaeger-collector-cassandra.yaml @@ -0,0 +1,455 @@ +name: jaeger-collector +synopsis: | + Jaeger collector receives and processes traces from Jaeger agents and clients +description: | + Jaeger collector receives traces from Jaeger agents and runs them through a processing pipeline. +usage: jaeger-collector [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-collector + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-collector completion - Generate the autocompletion script for the specified shell + - jaeger-collector docs - Generates documentation + - jaeger-collector env - Help about environment variables. + - jaeger-collector print-config - Print names and values of configuration options + - jaeger-collector status - Print the status. + - jaeger-collector version - Print the version. diff --git a/data/cli/1.61/jaeger-collector-elasticsearch.yaml b/data/cli/1.61/jaeger-collector-elasticsearch.yaml new file mode 100644 index 00000000..7c65967e --- /dev/null +++ b/data/cli/1.61/jaeger-collector-elasticsearch.yaml @@ -0,0 +1,597 @@ +name: jaeger-collector +synopsis: | + Jaeger collector receives and processes traces from Jaeger agents and clients +description: | + Jaeger collector receives traces from Jaeger agents and runs them through a processing pipeline. +usage: jaeger-collector [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: es-archive.adaptive-sampling.lookback + default_value: 72h0m0s + usage: | + How far back to look for the latest adaptive sampling probabilities + - name: es-archive.bulk.actions + default_value: "1000" + usage: | + The number of requests that can be enqueued before the bulk processor decides to commit + - name: es-archive.bulk.flush-interval + default_value: 200ms + usage: | + A time.Duration after which bulk requests are committed, regardless of other thresholds. Set to zero to disable. By default, this is disabled. + - name: es-archive.bulk.size + default_value: "5000000" + usage: | + The number of bytes that the bulk requests can take up before the bulk processor decides to commit + - name: es-archive.bulk.workers + default_value: "1" + usage: | + The number of workers that are able to receive bulk requests and eventually commit them to Elasticsearch + - name: es-archive.create-index-templates + default_value: "true" + usage: | + Create index templates at application startup. Set to false when templates are installed manually. + - name: es-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: es-archive.index-date-separator + default_value: '-' + usage: | + Optional date separator of Jaeger indices. For example "." creates "jaeger-span-2020.11.20". + - name: es-archive.index-prefix + usage: | + Optional prefix of Jaeger indices. For example "production" creates "production-jaeger-*". + - name: es-archive.index-rollover-frequency-adaptive-sampling + default_value: day + usage: | + Rotates jaeger-sampling indices over the given period. For example "day" creates "jaeger-sampling-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.index-rollover-frequency-services + default_value: day + usage: | + Rotates jaeger-service indices over the given period. For example "day" creates "jaeger-service-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.index-rollover-frequency-spans + default_value: day + usage: | + Rotates jaeger-span indices over the given period. For example "day" creates "jaeger-span-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.log-level + default_value: error + usage: | + The Elasticsearch client log-level. Valid levels: [debug, info, error] + - name: es-archive.max-doc-count + default_value: "10000" + usage: | + The maximum document count to return from an Elasticsearch query. This will also apply to aggregations. + - name: es-archive.num-replicas + default_value: "1" + usage: The number of replicas per index in Elasticsearch + - name: es-archive.num-shards + default_value: "5" + usage: The number of shards per index in Elasticsearch + - name: es-archive.password + usage: The password required by Elasticsearch + - name: es-archive.password-file + usage: | + Path to a file containing password. This file is watched for changes. + - name: es-archive.prioirity-dependencies-template + default_value: "0" + usage: Priority of jaeger-dependecies index template (ESv8 only) + - name: es-archive.prioirity-service-template + default_value: "0" + usage: Priority of jaeger-service index template (ESv8 only) + - name: es-archive.prioirity-span-template + default_value: "0" + usage: Priority of jaeger-span index template (ESv8 only) + - name: es-archive.remote-read-clusters + usage: | + Comma-separated list of Elasticsearch remote cluster names for cross-cluster querying.See Elasticsearch remote clusters and cross-cluster query api. + - name: es-archive.send-get-body-as + usage: HTTP verb for requests that contain a body [GET, POST]. + - name: es-archive.server-urls + default_value: http://127.0.0.1:9200 + usage: | + The comma-separated list of Elasticsearch servers, must be full url i.e. http://localhost:9200 + - name: es-archive.service-cache-ttl + default_value: 0s + usage: The TTL for the cache of known service names + - name: es-archive.sniffer + default_value: "false" + usage: | + The sniffer config for Elasticsearch; client uses sniffing process to find all nodes automatically, disable if not required + - name: es-archive.sniffer-tls-enabled + default_value: "false" + usage: | + Option to enable TLS when sniffing an Elasticsearch Cluster ; client uses sniffing process to find all nodes automatically, disabled by default + - name: es-archive.tags-as-fields.all + default_value: "false" + usage: | + (experimental) Store all span and process tags as object fields. If true .tags-as-fields.config-file and .tags-as-fields.include is ignored. Binary tags are always stored as nested objects. + - name: es-archive.tags-as-fields.config-file + usage: | + (experimental) Optional path to a file containing tag keys which will be stored as object fields. Each key should be on a separate line. Merged with .tags-as-fields.include + - name: es-archive.tags-as-fields.dot-replacement + default_value: '@' + usage: | + (experimental) The character used to replace dots (".") in tag keys stored as object fields. + - name: es-archive.tags-as-fields.include + usage: | + (experimental) Comma delimited list of tag keys which will be stored as object fields. Merged with the contents of .tags-as-fields.config-file + - name: es-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: es-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: es-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: es-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: es-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: es-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: es-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: es-archive.token-file + usage: | + Path to a file containing bearer token. This flag also loads CA if it is specified. + - name: es-archive.use-aliases + default_value: "false" + usage: | + Use read and write aliases for indices. Use this option with Elasticsearch rollover API. It requires an external component to create aliases before startup and then performing its management. Note that es.max-span-age will influence trace search window start times. + - name: es-archive.use-ilm + default_value: "false" + usage: | + (experimental) Option to enable ILM for jaeger span & service indices. Use this option with es-archive.use-aliases. It requires an external component to create aliases before startup and then performing its management. ILM policy must be manually created in ES before startup. Supported only for elasticsearch version 7+. + - name: es-archive.username + usage: | + The username required by Elasticsearch. The basic authentication also loads CA if it is specified. + - name: es-archive.version + default_value: "0" + usage: | + The major Elasticsearch version. If not specified, the value will be auto-detected from Elasticsearch. + - name: es.adaptive-sampling.lookback + default_value: 72h0m0s + usage: | + How far back to look for the latest adaptive sampling probabilities + - name: es.bulk.actions + default_value: "1000" + usage: | + The number of requests that can be enqueued before the bulk processor decides to commit + - name: es.bulk.flush-interval + default_value: 200ms + usage: | + A time.Duration after which bulk requests are committed, regardless of other thresholds. Set to zero to disable. By default, this is disabled. + - name: es.bulk.size + default_value: "5000000" + usage: | + The number of bytes that the bulk requests can take up before the bulk processor decides to commit + - name: es.bulk.workers + default_value: "1" + usage: | + The number of workers that are able to receive bulk requests and eventually commit them to Elasticsearch + - name: es.create-index-templates + default_value: "true" + usage: | + Create index templates at application startup. Set to false when templates are installed manually. + - name: es.index-date-separator + default_value: '-' + usage: | + Optional date separator of Jaeger indices. For example "." creates "jaeger-span-2020.11.20". + - name: es.index-prefix + usage: | + Optional prefix of Jaeger indices. For example "production" creates "production-jaeger-*". + - name: es.index-rollover-frequency-adaptive-sampling + default_value: day + usage: | + Rotates jaeger-sampling indices over the given period. For example "day" creates "jaeger-sampling-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.index-rollover-frequency-services + default_value: day + usage: | + Rotates jaeger-service indices over the given period. For example "day" creates "jaeger-service-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.index-rollover-frequency-spans + default_value: day + usage: | + Rotates jaeger-span indices over the given period. For example "day" creates "jaeger-span-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.log-level + default_value: error + usage: | + The Elasticsearch client log-level. Valid levels: [debug, info, error] + - name: es.max-doc-count + default_value: "10000" + usage: | + The maximum document count to return from an Elasticsearch query. This will also apply to aggregations. + - name: es.max-span-age + default_value: 72h0m0s + usage: The maximum lookback for spans in Elasticsearch + - name: es.num-replicas + default_value: "1" + usage: The number of replicas per index in Elasticsearch + - name: es.num-shards + default_value: "5" + usage: The number of shards per index in Elasticsearch + - name: es.password + usage: The password required by Elasticsearch + - name: es.password-file + usage: | + Path to a file containing password. This file is watched for changes. + - name: es.prioirity-dependencies-template + default_value: "0" + usage: Priority of jaeger-dependecies index template (ESv8 only) + - name: es.prioirity-service-template + default_value: "0" + usage: Priority of jaeger-service index template (ESv8 only) + - name: es.prioirity-span-template + default_value: "0" + usage: Priority of jaeger-span index template (ESv8 only) + - name: es.remote-read-clusters + usage: | + Comma-separated list of Elasticsearch remote cluster names for cross-cluster querying.See Elasticsearch remote clusters and cross-cluster query api. + - name: es.send-get-body-as + usage: HTTP verb for requests that contain a body [GET, POST]. + - name: es.server-urls + default_value: http://127.0.0.1:9200 + usage: | + The comma-separated list of Elasticsearch servers, must be full url i.e. http://localhost:9200 + - name: es.service-cache-ttl + default_value: 0s + usage: The TTL for the cache of known service names + - name: es.sniffer + default_value: "false" + usage: | + The sniffer config for Elasticsearch; client uses sniffing process to find all nodes automatically, disable if not required + - name: es.sniffer-tls-enabled + default_value: "false" + usage: | + Option to enable TLS when sniffing an Elasticsearch Cluster ; client uses sniffing process to find all nodes automatically, disabled by default + - name: es.tags-as-fields.all + default_value: "false" + usage: | + (experimental) Store all span and process tags as object fields. If true .tags-as-fields.config-file and .tags-as-fields.include is ignored. Binary tags are always stored as nested objects. + - name: es.tags-as-fields.config-file + usage: | + (experimental) Optional path to a file containing tag keys which will be stored as object fields. Each key should be on a separate line. Merged with .tags-as-fields.include + - name: es.tags-as-fields.dot-replacement + default_value: '@' + usage: | + (experimental) The character used to replace dots (".") in tag keys stored as object fields. + - name: es.tags-as-fields.include + usage: | + (experimental) Comma delimited list of tag keys which will be stored as object fields. Merged with the contents of .tags-as-fields.config-file + - name: es.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: es.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: es.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: es.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: es.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: es.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: es.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: es.token-file + usage: | + Path to a file containing bearer token. This flag also loads CA if it is specified. + - name: es.use-aliases + default_value: "false" + usage: | + Use read and write aliases for indices. Use this option with Elasticsearch rollover API. It requires an external component to create aliases before startup and then performing its management. Note that es.max-span-age will influence trace search window start times. + - name: es.use-ilm + default_value: "false" + usage: | + (experimental) Option to enable ILM for jaeger span & service indices. Use this option with es.use-aliases. It requires an external component to create aliases before startup and then performing its management. ILM policy must be manually created in ES before startup. Supported only for elasticsearch version 7+. + - name: es.username + usage: | + The username required by Elasticsearch. The basic authentication also loads CA if it is specified. + - name: es.version + default_value: "0" + usage: | + The major Elasticsearch version. If not specified, the value will be auto-detected from Elasticsearch. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-collector + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-collector completion - Generate the autocompletion script for the specified shell + - jaeger-collector docs - Generates documentation + - jaeger-collector env - Help about environment variables. + - jaeger-collector print-config - Print names and values of configuration options + - jaeger-collector status - Print the status. + - jaeger-collector version - Print the version. diff --git a/data/cli/1.61/jaeger-collector-file.yaml b/data/cli/1.61/jaeger-collector-file.yaml new file mode 100644 index 00000000..0a27a121 --- /dev/null +++ b/data/cli/1.61/jaeger-collector-file.yaml @@ -0,0 +1,455 @@ +name: jaeger-collector +synopsis: | + Jaeger collector receives and processes traces from Jaeger agents and clients +description: | + Jaeger collector receives traces from Jaeger agents and runs them through a processing pipeline. +usage: jaeger-collector [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-collector + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-collector completion - Generate the autocompletion script for the specified shell + - jaeger-collector docs - Generates documentation + - jaeger-collector env - Help about environment variables. + - jaeger-collector print-config - Print names and values of configuration options + - jaeger-collector status - Print the status. + - jaeger-collector version - Print the version. diff --git a/data/cli/1.61/jaeger-collector-kafka.yaml b/data/cli/1.61/jaeger-collector-kafka.yaml new file mode 100644 index 00000000..63c7d6c0 --- /dev/null +++ b/data/cli/1.61/jaeger-collector-kafka.yaml @@ -0,0 +1,399 @@ +name: jaeger-collector +synopsis: | + Jaeger collector receives and processes traces from Jaeger agents and clients +description: | + Jaeger collector receives traces from Jaeger agents and runs them through a processing pipeline. +usage: jaeger-collector [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-collector + - name: kafka.producer.authentication + default_value: none + usage: | + Authentication type used to authenticate with kafka cluster. e.g. none, kerberos, tls, plaintext + - name: kafka.producer.batch-linger + default_value: 0s + usage: | + (experimental) Time interval to wait before sending records to Kafka. Higher value reduce request to Kafka but increase latency and the possibility of data loss in case of process restart. See https://kafka.apache.org/documentation/ + - name: kafka.producer.batch-max-messages + default_value: "0" + usage: | + (experimental) Maximum number of message to batch before sending records to Kafka + - name: kafka.producer.batch-min-messages + default_value: "0" + usage: | + (experimental) The best-effort minimum number of messages needed to send a batch of records to Kafka. Higher value reduce request to Kafka but increase latency and the possibility of data loss in case of process restart. See https://kafka.apache.org/documentation/ + - name: kafka.producer.batch-size + default_value: "0" + usage: | + (experimental) Number of bytes to batch before sending records to Kafka. Higher value reduce request to Kafka but increase latency and the possibility of data loss in case of process restart. See https://kafka.apache.org/documentation/ + - name: kafka.producer.brokers + default_value: 127.0.0.1:9092 + usage: | + The comma-separated list of kafka brokers. i.e. '127.0.0.1:9092,0.0.0:1234' + - name: kafka.producer.compression + default_value: none + usage: | + (experimental) Type of compression (none, gzip, snappy, lz4, zstd) to use on messages + - name: kafka.producer.compression-level + default_value: "0" + usage: | + (experimental) compression level to use on messages. gzip = 1-9 (default = 6), snappy = none, lz4 = 1-17 (default = 9), zstd = -131072 - 22 (default = 3) + - name: kafka.producer.encoding + default_value: protobuf + usage: Encoding of spans ("json" or "protobuf") sent to kafka. + - name: kafka.producer.kerberos.config-file + default_value: /etc/krb5.conf + usage: Path to Kerberos configuration. i.e /etc/krb5.conf + - name: kafka.producer.kerberos.disable-fast-negotiation + default_value: "false" + usage: | + Disable FAST negotiation when not supported by KDC's like Active Directory. See https://github.com/jcmturner/gokrb5/blob/master/USAGE.md#active-directory-kdc-and-fast-negotiation. + - name: kafka.producer.kerberos.keytab-file + default_value: /etc/security/kafka.keytab + usage: Path to keytab file. i.e /etc/security/kafka.keytab + - name: kafka.producer.kerberos.password + usage: The Kerberos password used for authenticate with KDC + - name: kafka.producer.kerberos.realm + usage: Kerberos realm + - name: kafka.producer.kerberos.service-name + default_value: kafka + usage: Kerberos service name + - name: kafka.producer.kerberos.use-keytab + default_value: "false" + usage: | + Use of keytab instead of password, if this is true, keytab file will be used instead of password + - name: kafka.producer.kerberos.username + usage: The Kerberos username used for authenticate with KDC + - name: kafka.producer.max-message-bytes + default_value: "1000000" + usage: | + (experimental) The maximum permitted size of a message. Should be set equal to or smaller than the broker's `message.max.bytes`. + - name: kafka.producer.plaintext.mechanism + default_value: PLAIN + usage: | + The plaintext Mechanism for SASL/PLAIN authentication, e.g. 'SCRAM-SHA-256' or 'SCRAM-SHA-512' or 'PLAIN' + - name: kafka.producer.plaintext.password + usage: The plaintext Password for SASL/PLAIN authentication + - name: kafka.producer.plaintext.username + usage: The plaintext Username for SASL/PLAIN authentication + - name: kafka.producer.protocol-version + usage: Kafka protocol version - must be supported by kafka server + - name: kafka.producer.required-acks + default_value: local + usage: | + (experimental) Required kafka broker acknowledgement. i.e. noack, local, all + - name: kafka.producer.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: kafka.producer.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: kafka.producer.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: kafka.producer.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: kafka.producer.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: kafka.producer.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: kafka.producer.topic + default_value: jaeger-spans + usage: The name of the kafka topic + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-collector completion - Generate the autocompletion script for the specified shell + - jaeger-collector docs - Generates documentation + - jaeger-collector env - Help about environment variables. + - jaeger-collector print-config - Print names and values of configuration options + - jaeger-collector status - Print the status. + - jaeger-collector version - Print the version. diff --git a/data/cli/1.61/jaeger-collector.yaml b/data/cli/1.61/jaeger-collector.yaml new file mode 100644 index 00000000..0a27a121 --- /dev/null +++ b/data/cli/1.61/jaeger-collector.yaml @@ -0,0 +1,455 @@ +name: jaeger-collector +synopsis: | + Jaeger collector receives and processes traces from Jaeger agents and clients +description: | + Jaeger collector receives traces from Jaeger agents and runs them through a processing pipeline. +usage: jaeger-collector [flags] +options: + - name: admin.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: collector.enable-span-size-metrics + default_value: "false" + usage: | + Enables metrics based on processed span size, which are more expensive to calculate. + - name: collector.grpc-server.host-port + default_value: :14250 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.grpc-server.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.grpc-server.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http-server.host-port + default_value: :14268 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.http-server.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http-server.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.num-workers + default_value: "50" + usage: The number of workers pulling items from the queue + - name: collector.otlp.enabled + default_value: "true" + usage: | + Enables OpenTelemetry OTLP receiver on dedicated HTTP and gRPC ports + - name: collector.otlp.grpc.host-port + default_value: :4317 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's gRPC server + - name: collector.otlp.grpc.max-connection-age + default_value: 0s + usage: | + The maximum amount of time a connection may exist. Set this value to a few seconds or minutes on highly elastic environments, so that clients discover new collector nodes frequently. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-connection-age-grace + default_value: 0s + usage: | + The additive period after MaxConnectionAge after which the connection will be forcibly closed. See https://pkg.go.dev/google.golang.org/grpc/keepalive#ServerParameters + - name: collector.otlp.grpc.max-message-size + default_value: "4194304" + usage: | + The maximum receivable message size for the collector's gRPC server + - name: collector.otlp.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.grpc.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.otlp.http.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.otlp.http.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.otlp.http.host-port + default_value: :4318 + usage: | + The host:port (e.g. 127.0.0.1:12345 or :12345) of the collector's HTTP server + - name: collector.otlp.http.idle-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-header-timeout + default_value: 2s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.read-timeout + default_value: 0s + usage: See https://pkg.go.dev/net/http#Server + - name: collector.otlp.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.otlp.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.otlp.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.otlp.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.otlp.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.otlp.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.otlp.http.tls.reload-interval + default_value: 0s + usage: | + The duration after which the certificate will be reloaded (0s means will not be reloaded) + - name: collector.queue-size + default_value: "2000" + usage: The queue size of the collector + - name: collector.queue-size-memory + default_value: "0" + usage: | + (experimental) The max memory size in MiB to use for the dynamic queue. + - name: collector.tags + usage: | + One or more tags to be added to the Process tags of all spans passing through this collector. Ex: key1=value1,key2=${envVar:defaultValue} + - name: collector.zipkin.cors.allowed-headers + usage: | + Comma-separated CORS allowed headers. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers + - name: collector.zipkin.cors.allowed-origins + usage: | + Comma-separated CORS allowed origins. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin + - name: collector.zipkin.host-port + usage: | + The host:port (e.g. 127.0.0.1:9411 or :9411) of the collector's Zipkin server (disabled by default) + - name: collector.zipkin.keep-alive + default_value: "true" + usage: | + KeepAlive configures allow Keep-Alive for Zipkin HTTP server (enabled by default) + - name: collector.zipkin.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: collector.zipkin.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: collector.zipkin.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: collector.zipkin.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: collector.zipkin.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: collector.zipkin.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: collector.zipkin.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-collector + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: sampling.strategies-file + usage: | + The path for the sampling strategies file in JSON format. See sampling documentation to see format of the file + - name: sampling.strategies-reload-interval + default_value: 0s + usage: | + Reload interval to check and reload sampling strategies file. Zero value means no reloading + - name: sampling.strategies.bugfix-5270 + default_value: "false" + usage: | + Include default operation level strategies for Ratesampling type service level strategy. Cf. https://github.com/jaegertracing/jaeger/issues/5270 + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-collector completion - Generate the autocompletion script for the specified shell + - jaeger-collector docs - Generates documentation + - jaeger-collector env - Help about environment variables. + - jaeger-collector print-config - Print names and values of configuration options + - jaeger-collector status - Print the status. + - jaeger-collector version - Print the version. diff --git a/data/cli/1.61/jaeger-collector_completion.yaml b/data/cli/1.61/jaeger-collector_completion.yaml new file mode 100644 index 00000000..9cd30fdc --- /dev/null +++ b/data/cli/1.61/jaeger-collector_completion.yaml @@ -0,0 +1,16 @@ +name: jaeger-collector completion +synopsis: Generate the autocompletion script for the specified shell +description: | + Generate the autocompletion script for jaeger-collector for the specified shell. + See each sub-command's help for details on how to use the generated script. +options: + - name: help + shorthand: h + default_value: "false" + usage: help for completion +see_also: + - jaeger-collector - Jaeger collector receives and processes traces from Jaeger agents and clients + - jaeger-collector completion bash - Generate the autocompletion script for bash + - jaeger-collector completion fish - Generate the autocompletion script for fish + - jaeger-collector completion powershell - Generate the autocompletion script for powershell + - jaeger-collector completion zsh - Generate the autocompletion script for zsh diff --git a/data/cli/1.61/jaeger-collector_docs.yaml b/data/cli/1.61/jaeger-collector_docs.yaml new file mode 100644 index 00000000..be0ca8f2 --- /dev/null +++ b/data/cli/1.61/jaeger-collector_docs.yaml @@ -0,0 +1,17 @@ +name: jaeger-collector docs +synopsis: Generates documentation +description: Generates command and flags documentation +usage: jaeger-collector docs [flags] +options: + - name: dir + default_value: ./ + usage: Directory where generate the documentation. + - name: format + default_value: md + usage: 'Supported formats: [md man rst yaml].' + - name: help + shorthand: h + default_value: "false" + usage: help for docs +see_also: + - jaeger-collector - Jaeger collector receives and processes traces from Jaeger agents and clients diff --git a/data/cli/1.61/jaeger-collector_env.yaml b/data/cli/1.61/jaeger-collector_env.yaml new file mode 100644 index 00000000..2334fb88 --- /dev/null +++ b/data/cli/1.61/jaeger-collector_env.yaml @@ -0,0 +1,11 @@ +name: jaeger-collector env +synopsis: Help about environment variables. +description: "\nAll command line options can be provided via environment variables by converting\ntheir names to upper case and replacing punctuation with underscores. For example:\n\ncommand line option environment variable\n------------------------------------------------------------------\n--cassandra.connections-per-host CASSANDRA_CONNECTIONS_PER_HOST\n--metrics-backend METRICS_BACKEND\n\nThe following configuration options are only available via environment variables:\n\nSPAN_STORAGE_TYPE string The type of backend [cassandra, opensearch, elasticsearch, memory, kafka, badger, blackhole, grpc] used for trace storage. Multiple backends can be specified as comma-separated list, e.g. \"cassandra,elasticsearch\" (currently only for writing spans). Note that \"kafka\" is only valid in jaeger-collector; it is not a replacement for a proper storage backend, and only used as a buffer for spans when Jaeger is deployed in the collector+ingester configuration. (default \"cassandra\")\n\nDEPENDENCY_STORAGE_TYPE string The type of backend used for service dependencies storage. (default \"${SPAN_STORAGE_TYPE}\")\n\nSAMPLING_CONFIG_TYPE string The method [file, adaptive] used for determining the sampling rates served to clients configured with remote sampling enabled. \"file\" uses a periodically reloaded file and \"adaptive\" dynamically adjusts sampling rates based on current traffic. (default \"file\")\n\nSAMPLING_STORAGE_TYPE string The type of backend [cassandra, memory, badger] used for adaptive sampling storage when adaptive sampling is enabled via SAMPLING_CONFIG_TYPE. \n\nMETRICS_STORAGE_TYPE string The type of backend [prometheus] used as a metrics store with Service Performance Monitoring (https://www.jaegertracing.io/docs/latest/spm/). \n\n" +usage: jaeger-collector env [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for env +see_also: + - jaeger-collector - Jaeger collector receives and processes traces from Jaeger agents and clients diff --git a/data/cli/1.61/jaeger-collector_print-config.yaml b/data/cli/1.61/jaeger-collector_print-config.yaml new file mode 100644 index 00000000..59e4b0fb --- /dev/null +++ b/data/cli/1.61/jaeger-collector_print-config.yaml @@ -0,0 +1,17 @@ +name: jaeger-collector print-config +synopsis: Print names and values of configuration options +description: | + Print names and values of configuration options, distinguishing between default and user-assigned values +usage: jaeger-collector print-config [flags] +options: + - name: all + shorthand: a + default_value: "false" + usage: | + Print all configuration options including those with empty values + - name: help + shorthand: h + default_value: "false" + usage: help for print-config +see_also: + - jaeger-collector - Jaeger collector receives and processes traces from Jaeger agents and clients diff --git a/data/cli/1.61/jaeger-collector_status.yaml b/data/cli/1.61/jaeger-collector_status.yaml new file mode 100644 index 00000000..49011be6 --- /dev/null +++ b/data/cli/1.61/jaeger-collector_status.yaml @@ -0,0 +1,16 @@ +name: jaeger-collector status +synopsis: Print the status. +description: | + Print Jaeger component status information, exit non-zero on any error. +usage: jaeger-collector status [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for status + - name: status.http.host-port + default_value: :14269 + usage: | + The host:port (e.g. 127.0.0.1:14269 or :14269) for the health check +see_also: + - jaeger-collector - Jaeger collector receives and processes traces from Jaeger agents and clients diff --git a/data/cli/1.61/jaeger-collector_version.yaml b/data/cli/1.61/jaeger-collector_version.yaml new file mode 100644 index 00000000..39707abc --- /dev/null +++ b/data/cli/1.61/jaeger-collector_version.yaml @@ -0,0 +1,11 @@ +name: jaeger-collector version +synopsis: Print the version. +description: Print the version and build information. +usage: jaeger-collector version [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for version +see_also: + - jaeger-collector - Jaeger collector receives and processes traces from Jaeger agents and clients diff --git a/data/cli/1.61/jaeger-ingester-cassandra.yaml b/data/cli/1.61/jaeger-ingester-cassandra.yaml new file mode 100644 index 00000000..1d3bf7ca --- /dev/null +++ b/data/cli/1.61/jaeger-ingester-cassandra.yaml @@ -0,0 +1,311 @@ +name: jaeger-ingester +synopsis: Jaeger ingester consumes from Kafka and writes to storage. +description: | + Jaeger ingester consumes spans from a particular Kafka topic and writes them to a configured storage. +usage: jaeger-ingester [flags] +options: + - name: admin.http.host-port + default_value: :14270 + usage: | + The host:port (e.g. 127.0.0.1:14270 or :14270) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-ingester + - name: ingester.deadlockInterval + default_value: 0s + usage: | + Interval to check for deadlocks. If no messages gets processed in given time, ingester app will exit. Value of 0 disables deadlock check. + - name: ingester.parallelism + default_value: "1000" + usage: The number of messages to process in parallel + - name: kafka.consumer.authentication + default_value: none + usage: | + Authentication type used to authenticate with kafka cluster. e.g. none, kerberos, tls, plaintext + - name: kafka.consumer.brokers + default_value: 127.0.0.1:9092 + usage: | + The comma-separated list of kafka brokers. i.e. '127.0.0.1:9092,0.0.0:1234' + - name: kafka.consumer.client-id + default_value: jaeger-ingester + usage: The Consumer Client ID that ingester will use + - name: kafka.consumer.encoding + default_value: protobuf + usage: | + The encoding of spans ("json", "protobuf", "zipkin-thrift") consumed from kafka + - name: kafka.consumer.fetch-max-message-bytes + default_value: "1048576" + usage: | + The maximum number of message bytes to fetch from the broker in a single request. So you must be sure this is at least as large as your largest message. + - name: kafka.consumer.group-id + default_value: jaeger-ingester + usage: | + The Consumer Group that ingester will be consuming on behalf of + - name: kafka.consumer.kerberos.config-file + default_value: /etc/krb5.conf + usage: Path to Kerberos configuration. i.e /etc/krb5.conf + - name: kafka.consumer.kerberos.disable-fast-negotiation + default_value: "false" + usage: | + Disable FAST negotiation when not supported by KDC's like Active Directory. See https://github.com/jcmturner/gokrb5/blob/master/USAGE.md#active-directory-kdc-and-fast-negotiation. + - name: kafka.consumer.kerberos.keytab-file + default_value: /etc/security/kafka.keytab + usage: Path to keytab file. i.e /etc/security/kafka.keytab + - name: kafka.consumer.kerberos.password + usage: The Kerberos password used for authenticate with KDC + - name: kafka.consumer.kerberos.realm + usage: Kerberos realm + - name: kafka.consumer.kerberos.service-name + default_value: kafka + usage: Kerberos service name + - name: kafka.consumer.kerberos.use-keytab + default_value: "false" + usage: | + Use of keytab instead of password, if this is true, keytab file will be used instead of password + - name: kafka.consumer.kerberos.username + usage: The Kerberos username used for authenticate with KDC + - name: kafka.consumer.plaintext.mechanism + default_value: PLAIN + usage: | + The plaintext Mechanism for SASL/PLAIN authentication, e.g. 'SCRAM-SHA-256' or 'SCRAM-SHA-512' or 'PLAIN' + - name: kafka.consumer.plaintext.password + usage: The plaintext Password for SASL/PLAIN authentication + - name: kafka.consumer.plaintext.username + usage: The plaintext Username for SASL/PLAIN authentication + - name: kafka.consumer.protocol-version + usage: Kafka protocol version - must be supported by kafka server + - name: kafka.consumer.rack-id + usage: | + Rack identifier for this client. This can be any string value which indicates where this client is located. It corresponds with the broker config `broker.rack` + - name: kafka.consumer.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: kafka.consumer.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: kafka.consumer.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: kafka.consumer.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: kafka.consumer.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: kafka.consumer.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: kafka.consumer.topic + default_value: jaeger-spans + usage: The name of the kafka topic to consume from + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-ingester completion - Generate the autocompletion script for the specified shell + - jaeger-ingester docs - Generates documentation + - jaeger-ingester env - Help about environment variables. + - jaeger-ingester print-config - Print names and values of configuration options + - jaeger-ingester status - Print the status. + - jaeger-ingester version - Print the version. diff --git a/data/cli/1.61/jaeger-ingester-elasticsearch.yaml b/data/cli/1.61/jaeger-ingester-elasticsearch.yaml new file mode 100644 index 00000000..561bc5bc --- /dev/null +++ b/data/cli/1.61/jaeger-ingester-elasticsearch.yaml @@ -0,0 +1,453 @@ +name: jaeger-ingester +synopsis: Jaeger ingester consumes from Kafka and writes to storage. +description: | + Jaeger ingester consumes spans from a particular Kafka topic and writes them to a configured storage. +usage: jaeger-ingester [flags] +options: + - name: admin.http.host-port + default_value: :14270 + usage: | + The host:port (e.g. 127.0.0.1:14270 or :14270) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: es-archive.adaptive-sampling.lookback + default_value: 72h0m0s + usage: | + How far back to look for the latest adaptive sampling probabilities + - name: es-archive.bulk.actions + default_value: "1000" + usage: | + The number of requests that can be enqueued before the bulk processor decides to commit + - name: es-archive.bulk.flush-interval + default_value: 200ms + usage: | + A time.Duration after which bulk requests are committed, regardless of other thresholds. Set to zero to disable. By default, this is disabled. + - name: es-archive.bulk.size + default_value: "5000000" + usage: | + The number of bytes that the bulk requests can take up before the bulk processor decides to commit + - name: es-archive.bulk.workers + default_value: "1" + usage: | + The number of workers that are able to receive bulk requests and eventually commit them to Elasticsearch + - name: es-archive.create-index-templates + default_value: "true" + usage: | + Create index templates at application startup. Set to false when templates are installed manually. + - name: es-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: es-archive.index-date-separator + default_value: '-' + usage: | + Optional date separator of Jaeger indices. For example "." creates "jaeger-span-2020.11.20". + - name: es-archive.index-prefix + usage: | + Optional prefix of Jaeger indices. For example "production" creates "production-jaeger-*". + - name: es-archive.index-rollover-frequency-adaptive-sampling + default_value: day + usage: | + Rotates jaeger-sampling indices over the given period. For example "day" creates "jaeger-sampling-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.index-rollover-frequency-services + default_value: day + usage: | + Rotates jaeger-service indices over the given period. For example "day" creates "jaeger-service-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.index-rollover-frequency-spans + default_value: day + usage: | + Rotates jaeger-span indices over the given period. For example "day" creates "jaeger-span-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.log-level + default_value: error + usage: | + The Elasticsearch client log-level. Valid levels: [debug, info, error] + - name: es-archive.max-doc-count + default_value: "10000" + usage: | + The maximum document count to return from an Elasticsearch query. This will also apply to aggregations. + - name: es-archive.num-replicas + default_value: "1" + usage: The number of replicas per index in Elasticsearch + - name: es-archive.num-shards + default_value: "5" + usage: The number of shards per index in Elasticsearch + - name: es-archive.password + usage: The password required by Elasticsearch + - name: es-archive.password-file + usage: | + Path to a file containing password. This file is watched for changes. + - name: es-archive.prioirity-dependencies-template + default_value: "0" + usage: Priority of jaeger-dependecies index template (ESv8 only) + - name: es-archive.prioirity-service-template + default_value: "0" + usage: Priority of jaeger-service index template (ESv8 only) + - name: es-archive.prioirity-span-template + default_value: "0" + usage: Priority of jaeger-span index template (ESv8 only) + - name: es-archive.remote-read-clusters + usage: | + Comma-separated list of Elasticsearch remote cluster names for cross-cluster querying.See Elasticsearch remote clusters and cross-cluster query api. + - name: es-archive.send-get-body-as + usage: HTTP verb for requests that contain a body [GET, POST]. + - name: es-archive.server-urls + default_value: http://127.0.0.1:9200 + usage: | + The comma-separated list of Elasticsearch servers, must be full url i.e. http://localhost:9200 + - name: es-archive.service-cache-ttl + default_value: 0s + usage: The TTL for the cache of known service names + - name: es-archive.sniffer + default_value: "false" + usage: | + The sniffer config for Elasticsearch; client uses sniffing process to find all nodes automatically, disable if not required + - name: es-archive.sniffer-tls-enabled + default_value: "false" + usage: | + Option to enable TLS when sniffing an Elasticsearch Cluster ; client uses sniffing process to find all nodes automatically, disabled by default + - name: es-archive.tags-as-fields.all + default_value: "false" + usage: | + (experimental) Store all span and process tags as object fields. If true .tags-as-fields.config-file and .tags-as-fields.include is ignored. Binary tags are always stored as nested objects. + - name: es-archive.tags-as-fields.config-file + usage: | + (experimental) Optional path to a file containing tag keys which will be stored as object fields. Each key should be on a separate line. Merged with .tags-as-fields.include + - name: es-archive.tags-as-fields.dot-replacement + default_value: '@' + usage: | + (experimental) The character used to replace dots (".") in tag keys stored as object fields. + - name: es-archive.tags-as-fields.include + usage: | + (experimental) Comma delimited list of tag keys which will be stored as object fields. Merged with the contents of .tags-as-fields.config-file + - name: es-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: es-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: es-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: es-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: es-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: es-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: es-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: es-archive.token-file + usage: | + Path to a file containing bearer token. This flag also loads CA if it is specified. + - name: es-archive.use-aliases + default_value: "false" + usage: | + Use read and write aliases for indices. Use this option with Elasticsearch rollover API. It requires an external component to create aliases before startup and then performing its management. Note that es.max-span-age will influence trace search window start times. + - name: es-archive.use-ilm + default_value: "false" + usage: | + (experimental) Option to enable ILM for jaeger span & service indices. Use this option with es-archive.use-aliases. It requires an external component to create aliases before startup and then performing its management. ILM policy must be manually created in ES before startup. Supported only for elasticsearch version 7+. + - name: es-archive.username + usage: | + The username required by Elasticsearch. The basic authentication also loads CA if it is specified. + - name: es-archive.version + default_value: "0" + usage: | + The major Elasticsearch version. If not specified, the value will be auto-detected from Elasticsearch. + - name: es.adaptive-sampling.lookback + default_value: 72h0m0s + usage: | + How far back to look for the latest adaptive sampling probabilities + - name: es.bulk.actions + default_value: "1000" + usage: | + The number of requests that can be enqueued before the bulk processor decides to commit + - name: es.bulk.flush-interval + default_value: 200ms + usage: | + A time.Duration after which bulk requests are committed, regardless of other thresholds. Set to zero to disable. By default, this is disabled. + - name: es.bulk.size + default_value: "5000000" + usage: | + The number of bytes that the bulk requests can take up before the bulk processor decides to commit + - name: es.bulk.workers + default_value: "1" + usage: | + The number of workers that are able to receive bulk requests and eventually commit them to Elasticsearch + - name: es.create-index-templates + default_value: "true" + usage: | + Create index templates at application startup. Set to false when templates are installed manually. + - name: es.index-date-separator + default_value: '-' + usage: | + Optional date separator of Jaeger indices. For example "." creates "jaeger-span-2020.11.20". + - name: es.index-prefix + usage: | + Optional prefix of Jaeger indices. For example "production" creates "production-jaeger-*". + - name: es.index-rollover-frequency-adaptive-sampling + default_value: day + usage: | + Rotates jaeger-sampling indices over the given period. For example "day" creates "jaeger-sampling-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.index-rollover-frequency-services + default_value: day + usage: | + Rotates jaeger-service indices over the given period. For example "day" creates "jaeger-service-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.index-rollover-frequency-spans + default_value: day + usage: | + Rotates jaeger-span indices over the given period. For example "day" creates "jaeger-span-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.log-level + default_value: error + usage: | + The Elasticsearch client log-level. Valid levels: [debug, info, error] + - name: es.max-doc-count + default_value: "10000" + usage: | + The maximum document count to return from an Elasticsearch query. This will also apply to aggregations. + - name: es.max-span-age + default_value: 72h0m0s + usage: The maximum lookback for spans in Elasticsearch + - name: es.num-replicas + default_value: "1" + usage: The number of replicas per index in Elasticsearch + - name: es.num-shards + default_value: "5" + usage: The number of shards per index in Elasticsearch + - name: es.password + usage: The password required by Elasticsearch + - name: es.password-file + usage: | + Path to a file containing password. This file is watched for changes. + - name: es.prioirity-dependencies-template + default_value: "0" + usage: Priority of jaeger-dependecies index template (ESv8 only) + - name: es.prioirity-service-template + default_value: "0" + usage: Priority of jaeger-service index template (ESv8 only) + - name: es.prioirity-span-template + default_value: "0" + usage: Priority of jaeger-span index template (ESv8 only) + - name: es.remote-read-clusters + usage: | + Comma-separated list of Elasticsearch remote cluster names for cross-cluster querying.See Elasticsearch remote clusters and cross-cluster query api. + - name: es.send-get-body-as + usage: HTTP verb for requests that contain a body [GET, POST]. + - name: es.server-urls + default_value: http://127.0.0.1:9200 + usage: | + The comma-separated list of Elasticsearch servers, must be full url i.e. http://localhost:9200 + - name: es.service-cache-ttl + default_value: 0s + usage: The TTL for the cache of known service names + - name: es.sniffer + default_value: "false" + usage: | + The sniffer config for Elasticsearch; client uses sniffing process to find all nodes automatically, disable if not required + - name: es.sniffer-tls-enabled + default_value: "false" + usage: | + Option to enable TLS when sniffing an Elasticsearch Cluster ; client uses sniffing process to find all nodes automatically, disabled by default + - name: es.tags-as-fields.all + default_value: "false" + usage: | + (experimental) Store all span and process tags as object fields. If true .tags-as-fields.config-file and .tags-as-fields.include is ignored. Binary tags are always stored as nested objects. + - name: es.tags-as-fields.config-file + usage: | + (experimental) Optional path to a file containing tag keys which will be stored as object fields. Each key should be on a separate line. Merged with .tags-as-fields.include + - name: es.tags-as-fields.dot-replacement + default_value: '@' + usage: | + (experimental) The character used to replace dots (".") in tag keys stored as object fields. + - name: es.tags-as-fields.include + usage: | + (experimental) Comma delimited list of tag keys which will be stored as object fields. Merged with the contents of .tags-as-fields.config-file + - name: es.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: es.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: es.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: es.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: es.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: es.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: es.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: es.token-file + usage: | + Path to a file containing bearer token. This flag also loads CA if it is specified. + - name: es.use-aliases + default_value: "false" + usage: | + Use read and write aliases for indices. Use this option with Elasticsearch rollover API. It requires an external component to create aliases before startup and then performing its management. Note that es.max-span-age will influence trace search window start times. + - name: es.use-ilm + default_value: "false" + usage: | + (experimental) Option to enable ILM for jaeger span & service indices. Use this option with es.use-aliases. It requires an external component to create aliases before startup and then performing its management. ILM policy must be manually created in ES before startup. Supported only for elasticsearch version 7+. + - name: es.username + usage: | + The username required by Elasticsearch. The basic authentication also loads CA if it is specified. + - name: es.version + default_value: "0" + usage: | + The major Elasticsearch version. If not specified, the value will be auto-detected from Elasticsearch. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-ingester + - name: ingester.deadlockInterval + default_value: 0s + usage: | + Interval to check for deadlocks. If no messages gets processed in given time, ingester app will exit. Value of 0 disables deadlock check. + - name: ingester.parallelism + default_value: "1000" + usage: The number of messages to process in parallel + - name: kafka.consumer.authentication + default_value: none + usage: | + Authentication type used to authenticate with kafka cluster. e.g. none, kerberos, tls, plaintext + - name: kafka.consumer.brokers + default_value: 127.0.0.1:9092 + usage: | + The comma-separated list of kafka brokers. i.e. '127.0.0.1:9092,0.0.0:1234' + - name: kafka.consumer.client-id + default_value: jaeger-ingester + usage: The Consumer Client ID that ingester will use + - name: kafka.consumer.encoding + default_value: protobuf + usage: | + The encoding of spans ("json", "protobuf", "zipkin-thrift") consumed from kafka + - name: kafka.consumer.fetch-max-message-bytes + default_value: "1048576" + usage: | + The maximum number of message bytes to fetch from the broker in a single request. So you must be sure this is at least as large as your largest message. + - name: kafka.consumer.group-id + default_value: jaeger-ingester + usage: | + The Consumer Group that ingester will be consuming on behalf of + - name: kafka.consumer.kerberos.config-file + default_value: /etc/krb5.conf + usage: Path to Kerberos configuration. i.e /etc/krb5.conf + - name: kafka.consumer.kerberos.disable-fast-negotiation + default_value: "false" + usage: | + Disable FAST negotiation when not supported by KDC's like Active Directory. See https://github.com/jcmturner/gokrb5/blob/master/USAGE.md#active-directory-kdc-and-fast-negotiation. + - name: kafka.consumer.kerberos.keytab-file + default_value: /etc/security/kafka.keytab + usage: Path to keytab file. i.e /etc/security/kafka.keytab + - name: kafka.consumer.kerberos.password + usage: The Kerberos password used for authenticate with KDC + - name: kafka.consumer.kerberos.realm + usage: Kerberos realm + - name: kafka.consumer.kerberos.service-name + default_value: kafka + usage: Kerberos service name + - name: kafka.consumer.kerberos.use-keytab + default_value: "false" + usage: | + Use of keytab instead of password, if this is true, keytab file will be used instead of password + - name: kafka.consumer.kerberos.username + usage: The Kerberos username used for authenticate with KDC + - name: kafka.consumer.plaintext.mechanism + default_value: PLAIN + usage: | + The plaintext Mechanism for SASL/PLAIN authentication, e.g. 'SCRAM-SHA-256' or 'SCRAM-SHA-512' or 'PLAIN' + - name: kafka.consumer.plaintext.password + usage: The plaintext Password for SASL/PLAIN authentication + - name: kafka.consumer.plaintext.username + usage: The plaintext Username for SASL/PLAIN authentication + - name: kafka.consumer.protocol-version + usage: Kafka protocol version - must be supported by kafka server + - name: kafka.consumer.rack-id + usage: | + Rack identifier for this client. This can be any string value which indicates where this client is located. It corresponds with the broker config `broker.rack` + - name: kafka.consumer.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: kafka.consumer.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: kafka.consumer.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: kafka.consumer.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: kafka.consumer.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: kafka.consumer.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: kafka.consumer.topic + default_value: jaeger-spans + usage: The name of the kafka topic to consume from + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-ingester completion - Generate the autocompletion script for the specified shell + - jaeger-ingester docs - Generates documentation + - jaeger-ingester env - Help about environment variables. + - jaeger-ingester print-config - Print names and values of configuration options + - jaeger-ingester status - Print the status. + - jaeger-ingester version - Print the version. diff --git a/data/cli/1.61/jaeger-ingester.yaml b/data/cli/1.61/jaeger-ingester.yaml new file mode 100644 index 00000000..1d3bf7ca --- /dev/null +++ b/data/cli/1.61/jaeger-ingester.yaml @@ -0,0 +1,311 @@ +name: jaeger-ingester +synopsis: Jaeger ingester consumes from Kafka and writes to storage. +description: | + Jaeger ingester consumes spans from a particular Kafka topic and writes them to a configured storage. +usage: jaeger-ingester [flags] +options: + - name: admin.http.host-port + default_value: :14270 + usage: | + The host:port (e.g. 127.0.0.1:14270 or :14270) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: downsampling.hashsalt + usage: Salt used when hashing trace id for downsampling. + - name: downsampling.ratio + default_value: "1" + usage: | + Ratio of spans passed to storage after downsampling (between 0 and 1), e.g ratio = 0.3 means we are keeping 30% of spans and dropping 70% of spans; ratio = 1.0 disables downsampling. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-ingester + - name: ingester.deadlockInterval + default_value: 0s + usage: | + Interval to check for deadlocks. If no messages gets processed in given time, ingester app will exit. Value of 0 disables deadlock check. + - name: ingester.parallelism + default_value: "1000" + usage: The number of messages to process in parallel + - name: kafka.consumer.authentication + default_value: none + usage: | + Authentication type used to authenticate with kafka cluster. e.g. none, kerberos, tls, plaintext + - name: kafka.consumer.brokers + default_value: 127.0.0.1:9092 + usage: | + The comma-separated list of kafka brokers. i.e. '127.0.0.1:9092,0.0.0:1234' + - name: kafka.consumer.client-id + default_value: jaeger-ingester + usage: The Consumer Client ID that ingester will use + - name: kafka.consumer.encoding + default_value: protobuf + usage: | + The encoding of spans ("json", "protobuf", "zipkin-thrift") consumed from kafka + - name: kafka.consumer.fetch-max-message-bytes + default_value: "1048576" + usage: | + The maximum number of message bytes to fetch from the broker in a single request. So you must be sure this is at least as large as your largest message. + - name: kafka.consumer.group-id + default_value: jaeger-ingester + usage: | + The Consumer Group that ingester will be consuming on behalf of + - name: kafka.consumer.kerberos.config-file + default_value: /etc/krb5.conf + usage: Path to Kerberos configuration. i.e /etc/krb5.conf + - name: kafka.consumer.kerberos.disable-fast-negotiation + default_value: "false" + usage: | + Disable FAST negotiation when not supported by KDC's like Active Directory. See https://github.com/jcmturner/gokrb5/blob/master/USAGE.md#active-directory-kdc-and-fast-negotiation. + - name: kafka.consumer.kerberos.keytab-file + default_value: /etc/security/kafka.keytab + usage: Path to keytab file. i.e /etc/security/kafka.keytab + - name: kafka.consumer.kerberos.password + usage: The Kerberos password used for authenticate with KDC + - name: kafka.consumer.kerberos.realm + usage: Kerberos realm + - name: kafka.consumer.kerberos.service-name + default_value: kafka + usage: Kerberos service name + - name: kafka.consumer.kerberos.use-keytab + default_value: "false" + usage: | + Use of keytab instead of password, if this is true, keytab file will be used instead of password + - name: kafka.consumer.kerberos.username + usage: The Kerberos username used for authenticate with KDC + - name: kafka.consumer.plaintext.mechanism + default_value: PLAIN + usage: | + The plaintext Mechanism for SASL/PLAIN authentication, e.g. 'SCRAM-SHA-256' or 'SCRAM-SHA-512' or 'PLAIN' + - name: kafka.consumer.plaintext.password + usage: The plaintext Password for SASL/PLAIN authentication + - name: kafka.consumer.plaintext.username + usage: The plaintext Username for SASL/PLAIN authentication + - name: kafka.consumer.protocol-version + usage: Kafka protocol version - must be supported by kafka server + - name: kafka.consumer.rack-id + usage: | + Rack identifier for this client. This can be any string value which indicates where this client is located. It corresponds with the broker config `broker.rack` + - name: kafka.consumer.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: kafka.consumer.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: kafka.consumer.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: kafka.consumer.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: kafka.consumer.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: kafka.consumer.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: kafka.consumer.topic + default_value: jaeger-spans + usage: The name of the kafka topic to consume from + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-ingester completion - Generate the autocompletion script for the specified shell + - jaeger-ingester docs - Generates documentation + - jaeger-ingester env - Help about environment variables. + - jaeger-ingester print-config - Print names and values of configuration options + - jaeger-ingester status - Print the status. + - jaeger-ingester version - Print the version. diff --git a/data/cli/1.61/jaeger-ingester_completion.yaml b/data/cli/1.61/jaeger-ingester_completion.yaml new file mode 100644 index 00000000..a4f98a5a --- /dev/null +++ b/data/cli/1.61/jaeger-ingester_completion.yaml @@ -0,0 +1,16 @@ +name: jaeger-ingester completion +synopsis: Generate the autocompletion script for the specified shell +description: | + Generate the autocompletion script for jaeger-ingester for the specified shell. + See each sub-command's help for details on how to use the generated script. +options: + - name: help + shorthand: h + default_value: "false" + usage: help for completion +see_also: + - jaeger-ingester - Jaeger ingester consumes from Kafka and writes to storage. + - jaeger-ingester completion bash - Generate the autocompletion script for bash + - jaeger-ingester completion fish - Generate the autocompletion script for fish + - jaeger-ingester completion powershell - Generate the autocompletion script for powershell + - jaeger-ingester completion zsh - Generate the autocompletion script for zsh diff --git a/data/cli/1.61/jaeger-ingester_docs.yaml b/data/cli/1.61/jaeger-ingester_docs.yaml new file mode 100644 index 00000000..79274508 --- /dev/null +++ b/data/cli/1.61/jaeger-ingester_docs.yaml @@ -0,0 +1,17 @@ +name: jaeger-ingester docs +synopsis: Generates documentation +description: Generates command and flags documentation +usage: jaeger-ingester docs [flags] +options: + - name: dir + default_value: ./ + usage: Directory where generate the documentation. + - name: format + default_value: md + usage: 'Supported formats: [md man rst yaml].' + - name: help + shorthand: h + default_value: "false" + usage: help for docs +see_also: + - jaeger-ingester - Jaeger ingester consumes from Kafka and writes to storage. diff --git a/data/cli/1.61/jaeger-ingester_env.yaml b/data/cli/1.61/jaeger-ingester_env.yaml new file mode 100644 index 00000000..47c71efe --- /dev/null +++ b/data/cli/1.61/jaeger-ingester_env.yaml @@ -0,0 +1,11 @@ +name: jaeger-ingester env +synopsis: Help about environment variables. +description: "\nAll command line options can be provided via environment variables by converting\ntheir names to upper case and replacing punctuation with underscores. For example:\n\ncommand line option environment variable\n------------------------------------------------------------------\n--cassandra.connections-per-host CASSANDRA_CONNECTIONS_PER_HOST\n--metrics-backend METRICS_BACKEND\n\nThe following configuration options are only available via environment variables:\n\nSPAN_STORAGE_TYPE string The type of backend [cassandra, opensearch, elasticsearch, memory, kafka, badger, blackhole, grpc] used for trace storage. Multiple backends can be specified as comma-separated list, e.g. \"cassandra,elasticsearch\" (currently only for writing spans). Note that \"kafka\" is only valid in jaeger-collector; it is not a replacement for a proper storage backend, and only used as a buffer for spans when Jaeger is deployed in the collector+ingester configuration. (default \"cassandra\")\n\nDEPENDENCY_STORAGE_TYPE string The type of backend used for service dependencies storage. (default \"${SPAN_STORAGE_TYPE}\")\n\nSAMPLING_CONFIG_TYPE string The method [file, adaptive] used for determining the sampling rates served to clients configured with remote sampling enabled. \"file\" uses a periodically reloaded file and \"adaptive\" dynamically adjusts sampling rates based on current traffic. (default \"file\")\n\nSAMPLING_STORAGE_TYPE string The type of backend [cassandra, memory, badger] used for adaptive sampling storage when adaptive sampling is enabled via SAMPLING_CONFIG_TYPE. \n\nMETRICS_STORAGE_TYPE string The type of backend [prometheus] used as a metrics store with Service Performance Monitoring (https://www.jaegertracing.io/docs/latest/spm/). \n\n" +usage: jaeger-ingester env [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for env +see_also: + - jaeger-ingester - Jaeger ingester consumes from Kafka and writes to storage. diff --git a/data/cli/1.61/jaeger-ingester_print-config.yaml b/data/cli/1.61/jaeger-ingester_print-config.yaml new file mode 100644 index 00000000..e0dc9211 --- /dev/null +++ b/data/cli/1.61/jaeger-ingester_print-config.yaml @@ -0,0 +1,17 @@ +name: jaeger-ingester print-config +synopsis: Print names and values of configuration options +description: | + Print names and values of configuration options, distinguishing between default and user-assigned values +usage: jaeger-ingester print-config [flags] +options: + - name: all + shorthand: a + default_value: "false" + usage: | + Print all configuration options including those with empty values + - name: help + shorthand: h + default_value: "false" + usage: help for print-config +see_also: + - jaeger-ingester - Jaeger ingester consumes from Kafka and writes to storage. diff --git a/data/cli/1.61/jaeger-ingester_status.yaml b/data/cli/1.61/jaeger-ingester_status.yaml new file mode 100644 index 00000000..4e625502 --- /dev/null +++ b/data/cli/1.61/jaeger-ingester_status.yaml @@ -0,0 +1,16 @@ +name: jaeger-ingester status +synopsis: Print the status. +description: | + Print Jaeger component status information, exit non-zero on any error. +usage: jaeger-ingester status [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for status + - name: status.http.host-port + default_value: :14270 + usage: | + The host:port (e.g. 127.0.0.1:14270 or :14270) for the health check +see_also: + - jaeger-ingester - Jaeger ingester consumes from Kafka and writes to storage. diff --git a/data/cli/1.61/jaeger-ingester_version.yaml b/data/cli/1.61/jaeger-ingester_version.yaml new file mode 100644 index 00000000..d275bc0e --- /dev/null +++ b/data/cli/1.61/jaeger-ingester_version.yaml @@ -0,0 +1,11 @@ +name: jaeger-ingester version +synopsis: Print the version. +description: Print the version and build information. +usage: jaeger-ingester version [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for version +see_also: + - jaeger-ingester - Jaeger ingester consumes from Kafka and writes to storage. diff --git a/data/cli/1.61/jaeger-query-cassandra.yaml b/data/cli/1.61/jaeger-query-cassandra.yaml new file mode 100644 index 00000000..40c0403f --- /dev/null +++ b/data/cli/1.61/jaeger-query-cassandra.yaml @@ -0,0 +1,303 @@ +name: jaeger-query +synopsis: | + Jaeger query service provides a Web UI and an API for accessing trace data. +description: | + Jaeger query service provides a Web UI and an API for accessing trace data. +usage: jaeger-query [flags] +options: + - name: admin.http.host-port + default_value: :16687 + usage: | + The host:port (e.g. 127.0.0.1:16687 or :16687) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-query + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-query completion - Generate the autocompletion script for the specified shell + - jaeger-query docs - Generates documentation + - jaeger-query env - Help about environment variables. + - jaeger-query print-config - Print names and values of configuration options + - jaeger-query status - Print the status. + - jaeger-query version - Print the version. diff --git a/data/cli/1.61/jaeger-query-elasticsearch.yaml b/data/cli/1.61/jaeger-query-elasticsearch.yaml new file mode 100644 index 00000000..f1bdaa8c --- /dev/null +++ b/data/cli/1.61/jaeger-query-elasticsearch.yaml @@ -0,0 +1,445 @@ +name: jaeger-query +synopsis: | + Jaeger query service provides a Web UI and an API for accessing trace data. +description: | + Jaeger query service provides a Web UI and an API for accessing trace data. +usage: jaeger-query [flags] +options: + - name: admin.http.host-port + default_value: :16687 + usage: | + The host:port (e.g. 127.0.0.1:16687 or :16687) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: es-archive.adaptive-sampling.lookback + default_value: 72h0m0s + usage: | + How far back to look for the latest adaptive sampling probabilities + - name: es-archive.bulk.actions + default_value: "1000" + usage: | + The number of requests that can be enqueued before the bulk processor decides to commit + - name: es-archive.bulk.flush-interval + default_value: 200ms + usage: | + A time.Duration after which bulk requests are committed, regardless of other thresholds. Set to zero to disable. By default, this is disabled. + - name: es-archive.bulk.size + default_value: "5000000" + usage: | + The number of bytes that the bulk requests can take up before the bulk processor decides to commit + - name: es-archive.bulk.workers + default_value: "1" + usage: | + The number of workers that are able to receive bulk requests and eventually commit them to Elasticsearch + - name: es-archive.create-index-templates + default_value: "true" + usage: | + Create index templates at application startup. Set to false when templates are installed manually. + - name: es-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: es-archive.index-date-separator + default_value: '-' + usage: | + Optional date separator of Jaeger indices. For example "." creates "jaeger-span-2020.11.20". + - name: es-archive.index-prefix + usage: | + Optional prefix of Jaeger indices. For example "production" creates "production-jaeger-*". + - name: es-archive.index-rollover-frequency-adaptive-sampling + default_value: day + usage: | + Rotates jaeger-sampling indices over the given period. For example "day" creates "jaeger-sampling-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.index-rollover-frequency-services + default_value: day + usage: | + Rotates jaeger-service indices over the given period. For example "day" creates "jaeger-service-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.index-rollover-frequency-spans + default_value: day + usage: | + Rotates jaeger-span indices over the given period. For example "day" creates "jaeger-span-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es-archive.log-level + default_value: error + usage: | + The Elasticsearch client log-level. Valid levels: [debug, info, error] + - name: es-archive.max-doc-count + default_value: "10000" + usage: | + The maximum document count to return from an Elasticsearch query. This will also apply to aggregations. + - name: es-archive.num-replicas + default_value: "1" + usage: The number of replicas per index in Elasticsearch + - name: es-archive.num-shards + default_value: "5" + usage: The number of shards per index in Elasticsearch + - name: es-archive.password + usage: The password required by Elasticsearch + - name: es-archive.password-file + usage: | + Path to a file containing password. This file is watched for changes. + - name: es-archive.prioirity-dependencies-template + default_value: "0" + usage: Priority of jaeger-dependecies index template (ESv8 only) + - name: es-archive.prioirity-service-template + default_value: "0" + usage: Priority of jaeger-service index template (ESv8 only) + - name: es-archive.prioirity-span-template + default_value: "0" + usage: Priority of jaeger-span index template (ESv8 only) + - name: es-archive.remote-read-clusters + usage: | + Comma-separated list of Elasticsearch remote cluster names for cross-cluster querying.See Elasticsearch remote clusters and cross-cluster query api. + - name: es-archive.send-get-body-as + usage: HTTP verb for requests that contain a body [GET, POST]. + - name: es-archive.server-urls + default_value: http://127.0.0.1:9200 + usage: | + The comma-separated list of Elasticsearch servers, must be full url i.e. http://localhost:9200 + - name: es-archive.service-cache-ttl + default_value: 0s + usage: The TTL for the cache of known service names + - name: es-archive.sniffer + default_value: "false" + usage: | + The sniffer config for Elasticsearch; client uses sniffing process to find all nodes automatically, disable if not required + - name: es-archive.sniffer-tls-enabled + default_value: "false" + usage: | + Option to enable TLS when sniffing an Elasticsearch Cluster ; client uses sniffing process to find all nodes automatically, disabled by default + - name: es-archive.tags-as-fields.all + default_value: "false" + usage: | + (experimental) Store all span and process tags as object fields. If true .tags-as-fields.config-file and .tags-as-fields.include is ignored. Binary tags are always stored as nested objects. + - name: es-archive.tags-as-fields.config-file + usage: | + (experimental) Optional path to a file containing tag keys which will be stored as object fields. Each key should be on a separate line. Merged with .tags-as-fields.include + - name: es-archive.tags-as-fields.dot-replacement + default_value: '@' + usage: | + (experimental) The character used to replace dots (".") in tag keys stored as object fields. + - name: es-archive.tags-as-fields.include + usage: | + (experimental) Comma delimited list of tag keys which will be stored as object fields. Merged with the contents of .tags-as-fields.config-file + - name: es-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: es-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: es-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: es-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: es-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: es-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: es-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: es-archive.token-file + usage: | + Path to a file containing bearer token. This flag also loads CA if it is specified. + - name: es-archive.use-aliases + default_value: "false" + usage: | + Use read and write aliases for indices. Use this option with Elasticsearch rollover API. It requires an external component to create aliases before startup and then performing its management. Note that es.max-span-age will influence trace search window start times. + - name: es-archive.use-ilm + default_value: "false" + usage: | + (experimental) Option to enable ILM for jaeger span & service indices. Use this option with es-archive.use-aliases. It requires an external component to create aliases before startup and then performing its management. ILM policy must be manually created in ES before startup. Supported only for elasticsearch version 7+. + - name: es-archive.username + usage: | + The username required by Elasticsearch. The basic authentication also loads CA if it is specified. + - name: es-archive.version + default_value: "0" + usage: | + The major Elasticsearch version. If not specified, the value will be auto-detected from Elasticsearch. + - name: es.adaptive-sampling.lookback + default_value: 72h0m0s + usage: | + How far back to look for the latest adaptive sampling probabilities + - name: es.bulk.actions + default_value: "1000" + usage: | + The number of requests that can be enqueued before the bulk processor decides to commit + - name: es.bulk.flush-interval + default_value: 200ms + usage: | + A time.Duration after which bulk requests are committed, regardless of other thresholds. Set to zero to disable. By default, this is disabled. + - name: es.bulk.size + default_value: "5000000" + usage: | + The number of bytes that the bulk requests can take up before the bulk processor decides to commit + - name: es.bulk.workers + default_value: "1" + usage: | + The number of workers that are able to receive bulk requests and eventually commit them to Elasticsearch + - name: es.create-index-templates + default_value: "true" + usage: | + Create index templates at application startup. Set to false when templates are installed manually. + - name: es.index-date-separator + default_value: '-' + usage: | + Optional date separator of Jaeger indices. For example "." creates "jaeger-span-2020.11.20". + - name: es.index-prefix + usage: | + Optional prefix of Jaeger indices. For example "production" creates "production-jaeger-*". + - name: es.index-rollover-frequency-adaptive-sampling + default_value: day + usage: | + Rotates jaeger-sampling indices over the given period. For example "day" creates "jaeger-sampling-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.index-rollover-frequency-services + default_value: day + usage: | + Rotates jaeger-service indices over the given period. For example "day" creates "jaeger-service-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.index-rollover-frequency-spans + default_value: day + usage: | + Rotates jaeger-span indices over the given period. For example "day" creates "jaeger-span-yyyy-MM-dd" every day after UTC 12AM. Valid options: [hour, day]. This does not delete old indices. For details on complete index management solutions supported by Jaeger, refer to: https://www.jaegertracing.io/docs/deployment/#elasticsearch-rollover + - name: es.log-level + default_value: error + usage: | + The Elasticsearch client log-level. Valid levels: [debug, info, error] + - name: es.max-doc-count + default_value: "10000" + usage: | + The maximum document count to return from an Elasticsearch query. This will also apply to aggregations. + - name: es.max-span-age + default_value: 72h0m0s + usage: The maximum lookback for spans in Elasticsearch + - name: es.num-replicas + default_value: "1" + usage: The number of replicas per index in Elasticsearch + - name: es.num-shards + default_value: "5" + usage: The number of shards per index in Elasticsearch + - name: es.password + usage: The password required by Elasticsearch + - name: es.password-file + usage: | + Path to a file containing password. This file is watched for changes. + - name: es.prioirity-dependencies-template + default_value: "0" + usage: Priority of jaeger-dependecies index template (ESv8 only) + - name: es.prioirity-service-template + default_value: "0" + usage: Priority of jaeger-service index template (ESv8 only) + - name: es.prioirity-span-template + default_value: "0" + usage: Priority of jaeger-span index template (ESv8 only) + - name: es.remote-read-clusters + usage: | + Comma-separated list of Elasticsearch remote cluster names for cross-cluster querying.See Elasticsearch remote clusters and cross-cluster query api. + - name: es.send-get-body-as + usage: HTTP verb for requests that contain a body [GET, POST]. + - name: es.server-urls + default_value: http://127.0.0.1:9200 + usage: | + The comma-separated list of Elasticsearch servers, must be full url i.e. http://localhost:9200 + - name: es.service-cache-ttl + default_value: 0s + usage: The TTL for the cache of known service names + - name: es.sniffer + default_value: "false" + usage: | + The sniffer config for Elasticsearch; client uses sniffing process to find all nodes automatically, disable if not required + - name: es.sniffer-tls-enabled + default_value: "false" + usage: | + Option to enable TLS when sniffing an Elasticsearch Cluster ; client uses sniffing process to find all nodes automatically, disabled by default + - name: es.tags-as-fields.all + default_value: "false" + usage: | + (experimental) Store all span and process tags as object fields. If true .tags-as-fields.config-file and .tags-as-fields.include is ignored. Binary tags are always stored as nested objects. + - name: es.tags-as-fields.config-file + usage: | + (experimental) Optional path to a file containing tag keys which will be stored as object fields. Each key should be on a separate line. Merged with .tags-as-fields.include + - name: es.tags-as-fields.dot-replacement + default_value: '@' + usage: | + (experimental) The character used to replace dots (".") in tag keys stored as object fields. + - name: es.tags-as-fields.include + usage: | + (experimental) Comma delimited list of tag keys which will be stored as object fields. Merged with the contents of .tags-as-fields.config-file + - name: es.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: es.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: es.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: es.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: es.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: es.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: es.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: es.token-file + usage: | + Path to a file containing bearer token. This flag also loads CA if it is specified. + - name: es.use-aliases + default_value: "false" + usage: | + Use read and write aliases for indices. Use this option with Elasticsearch rollover API. It requires an external component to create aliases before startup and then performing its management. Note that es.max-span-age will influence trace search window start times. + - name: es.use-ilm + default_value: "false" + usage: | + (experimental) Option to enable ILM for jaeger span & service indices. Use this option with es.use-aliases. It requires an external component to create aliases before startup and then performing its management. ILM policy must be manually created in ES before startup. Supported only for elasticsearch version 7+. + - name: es.username + usage: | + The username required by Elasticsearch. The basic authentication also loads CA if it is specified. + - name: es.version + default_value: "0" + usage: | + The major Elasticsearch version. If not specified, the value will be auto-detected from Elasticsearch. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-query + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-query completion - Generate the autocompletion script for the specified shell + - jaeger-query docs - Generates documentation + - jaeger-query env - Help about environment variables. + - jaeger-query print-config - Print names and values of configuration options + - jaeger-query status - Print the status. + - jaeger-query version - Print the version. diff --git a/data/cli/1.61/jaeger-query-prometheus.yaml b/data/cli/1.61/jaeger-query-prometheus.yaml new file mode 100644 index 00000000..f415db82 --- /dev/null +++ b/data/cli/1.61/jaeger-query-prometheus.yaml @@ -0,0 +1,351 @@ +name: jaeger-query +synopsis: | + Jaeger query service provides a Web UI and an API for accessing trace data. +description: | + Jaeger query service provides a Web UI and an API for accessing trace data. +usage: jaeger-query [flags] +options: + - name: admin.http.host-port + default_value: :16687 + usage: | + The host:port (e.g. 127.0.0.1:16687 or :16687) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-query + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: prometheus.connect-timeout + default_value: 30s + usage: | + The period to wait for a connection to Prometheus when executing queries. + - name: prometheus.query.duration-unit + default_value: ms + usage: | + The units used for the "latency" histogram. It can be either "ms" or "s" and should be consistent with the histogram unit value set in the spanmetrics connector (see: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/connector/spanmetricsconnector#configurations). This also helps jaeger-query determine the metric name when querying for "latency" metrics. + - name: prometheus.query.namespace + usage: | + The metric namespace that is prefixed to the metric name. A '.' separator will be added between the namespace and the metric name. + - name: prometheus.query.normalize-calls + default_value: "false" + usage: "Whether to normalize the \"calls\" metric name according to https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/pkg/translator/prometheus/README.md. For example: \"calls\" (not normalized) -> \"calls_total\" (normalized), \n" + - name: prometheus.query.normalize-duration + default_value: "false" + usage: | + Whether to normalize the "duration" metric name according to https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/pkg/translator/prometheus/README.md. For example: "duration_bucket" (not normalized) -> "duration_milliseconds_bucket (normalized)" + - name: prometheus.server-url + default_value: http://localhost:9090 + usage: | + The Prometheus server's URL, must include the protocol scheme e.g. http://localhost:9090 + - name: prometheus.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: prometheus.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: prometheus.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: prometheus.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: prometheus.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: prometheus.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: prometheus.token-file + usage: | + The path to a file containing the bearer token which will be included when executing queries against the Prometheus API. + - name: prometheus.token-override-from-context + default_value: "true" + usage: | + Whether the bearer token should be overridden from context (incoming request) + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-query completion - Generate the autocompletion script for the specified shell + - jaeger-query docs - Generates documentation + - jaeger-query env - Help about environment variables. + - jaeger-query print-config - Print names and values of configuration options + - jaeger-query status - Print the status. + - jaeger-query version - Print the version. diff --git a/data/cli/1.61/jaeger-query.yaml b/data/cli/1.61/jaeger-query.yaml new file mode 100644 index 00000000..40c0403f --- /dev/null +++ b/data/cli/1.61/jaeger-query.yaml @@ -0,0 +1,303 @@ +name: jaeger-query +synopsis: | + Jaeger query service provides a Web UI and an API for accessing trace data. +description: | + Jaeger query service provides a Web UI and an API for accessing trace data. +usage: jaeger-query [flags] +options: + - name: admin.http.host-port + default_value: :16687 + usage: | + The host:port (e.g. 127.0.0.1:16687 or :16687) for the admin server, including health check, /metrics, etc. + - name: admin.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: admin.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: admin.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: admin.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: admin.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: admin.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: admin.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: cassandra-archive.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra-archive.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra-archive.connections-per-host + default_value: "0" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra-archive.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra-archive.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra-archive.enabled + default_value: "false" + usage: Enable extra storage + - name: cassandra-archive.keyspace + usage: The Cassandra keyspace for Jaeger data + - name: cassandra-archive.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra-archive.max-retry-attempts + default_value: "0" + usage: The number of attempts when reading from Cassandra + - name: cassandra-archive.password + usage: Password for password authentication for Cassandra + - name: cassandra-archive.port + default_value: "0" + usage: The port for cassandra + - name: cassandra-archive.proto-version + default_value: "0" + usage: The Cassandra protocol version + - name: cassandra-archive.reconnect-interval + default_value: 0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra-archive.servers + usage: The comma-separated list of Cassandra servers + - name: cassandra-archive.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra-archive.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra-archive.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra-archive.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra-archive.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra-archive.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra-archive.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra-archive.username + usage: Username for password authentication for Cassandra + - name: cassandra.basic.allowed-authenticators + usage: | + The comma-separated list of allowed password authenticators for Cassandra.If none are specified, there is a default 'approved' list that is used (https://github.com/gocql/gocql/blob/34fdeebefcbf183ed7f916f931aa0586fdaa1b40/conn.go#L27). If a non-empty list is provided, only specified authenticators are allowed. + - name: cassandra.connect-timeout + default_value: 0s + usage: Timeout used for connections to Cassandra Servers + - name: cassandra.connections-per-host + default_value: "2" + usage: | + The number of Cassandra connections from a single backend instance + - name: cassandra.consistency + usage: | + The Cassandra consistency level, e.g. ANY, ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, LOCAL_ONE (default LOCAL_ONE) + - name: cassandra.disable-compression + default_value: "false" + usage: | + Disables the use of the default Snappy Compression while connecting to the Cassandra Cluster if set to true. This is useful for connecting to Cassandra Clusters(like Azure Cosmos Db with Cassandra API) that do not support SnappyCompression + - name: cassandra.index.logs + default_value: "true" + usage: Controls log field indexing. Set to false to disable. + - name: cassandra.index.process-tags + default_value: "true" + usage: Controls process tag indexing. Set to false to disable. + - name: cassandra.index.tag-blacklist + usage: | + The comma-separated list of span tags to blacklist from being indexed. All other tags will be indexed. Mutually exclusive with the whitelist option. + - name: cassandra.index.tag-whitelist + usage: | + The comma-separated list of span tags to whitelist for being indexed. All other tags will not be indexed. Mutually exclusive with the blacklist option. + - name: cassandra.index.tags + default_value: "true" + usage: Controls tag indexing. Set to false to disable. + - name: cassandra.keyspace + default_value: jaeger_v1_test + usage: The Cassandra keyspace for Jaeger data + - name: cassandra.local-dc + usage: | + The name of the Cassandra local data center for DC Aware host selection + - name: cassandra.max-retry-attempts + default_value: "3" + usage: The number of attempts when reading from Cassandra + - name: cassandra.password + usage: Password for password authentication for Cassandra + - name: cassandra.port + default_value: "9042" + usage: The port for cassandra + - name: cassandra.proto-version + default_value: "4" + usage: The Cassandra protocol version + - name: cassandra.reconnect-interval + default_value: 1m0s + usage: Reconnect interval to retry connecting to downed hosts + - name: cassandra.servers + default_value: 127.0.0.1 + usage: The comma-separated list of Cassandra servers + - name: cassandra.socket-keep-alive + default_value: 0s + usage: Cassandra's keepalive period to use, enabled if > 0 + - name: cassandra.span-store-write-cache-ttl + default_value: 12h0m0s + usage: | + The duration to wait before rewriting an existing service or operation name + - name: cassandra.timeout + default_value: 0s + usage: Timeout used for queries. A Timeout of zero means no timeout + - name: cassandra.tls.ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify the remote server(s) (by default will use the system truststore) + - name: cassandra.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this process to the remote server(s) + - name: cassandra.tls.enabled + default_value: "false" + usage: Enable TLS when talking to the remote server(s) + - name: cassandra.tls.key + usage: | + Path to a TLS Private Key file, used to identify this process to the remote server(s) + - name: cassandra.tls.server-name + usage: | + Override the TLS server name we expect in the certificate of the remote server(s) + - name: cassandra.tls.skip-host-verify + default_value: "false" + usage: | + (insecure) Skip server's certificate chain and host name verification + - name: cassandra.username + usage: Username for password authentication for Cassandra + - name: config-file + usage: | + Configuration file in JSON, TOML, YAML, HCL, or Java properties formats (default none). See spf13/viper for precedence. + - name: help + shorthand: h + default_value: "false" + usage: help for jaeger-query + - name: log-encoding + default_value: json + usage: Log encoding. Supported values are 'json' and 'console'. + - name: log-level + default_value: info + usage: | + Minimal allowed log Level. For more levels see https://github.com/uber-go/zap + - name: metrics-backend + default_value: prometheus + usage: | + Defines which metrics backend to use for metrics reporting: prometheus or none + - name: metrics-http-route + default_value: /metrics + usage: | + Defines the route of HTTP endpoint for metrics backends that support scraping + - name: multi-tenancy.enabled + default_value: "false" + usage: Enable tenancy header when receiving or querying + - name: multi-tenancy.header + default_value: x-tenant + usage: HTTP header carrying tenant + - name: multi-tenancy.tenants + usage: | + comma-separated list of allowed values for --multi-tenancy.header header. (If not supplied, tenants are not restricted) + - name: query.additional-headers + default_value: '[]' + usage: | + Additional HTTP response headers. Can be specified multiple times. Format: "Key: Value" + - name: query.base-path + default_value: / + usage: | + The base path for all HTTP routes, e.g. /jaeger; useful when running behind a reverse proxy. See https://github.com/jaegertracing/jaeger/blob/main/examples/reverse-proxy/README.md + - name: query.bearer-token-propagation + default_value: "false" + usage: | + Allow propagation of bearer token to be used by storage plugins + - name: query.enable-tracing + default_value: "false" + usage: Enables emitting jaeger-query traces + - name: query.grpc-server.host-port + default_value: :16685 + usage: | + The host:port (e.g. 127.0.0.1:14250 or :14250) of the query's gRPC server + - name: query.grpc.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.grpc.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.grpc.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.grpc.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.grpc.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.grpc.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.grpc.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http-server.host-port + default_value: :16686 + usage: | + The host:port (e.g. 127.0.0.1:14268 or :14268) of the query's HTTP server + - name: query.http.tls.cert + usage: | + Path to a TLS Certificate file, used to identify this server to clients + - name: query.http.tls.cipher-suites + usage: | + Comma-separated list of cipher suites for the server, values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). + - name: query.http.tls.client-ca + usage: | + Path to a TLS CA (Certification Authority) file used to verify certificates presented by clients (if unset, all clients are permitted) + - name: query.http.tls.enabled + default_value: "false" + usage: Enable TLS on the server + - name: query.http.tls.key + usage: | + Path to a TLS Private Key file, used to identify this server to clients + - name: query.http.tls.max-version + usage: | + Maximum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.http.tls.min-version + usage: | + Minimum TLS version supported (Possible values: 1.0, 1.1, 1.2, 1.3) + - name: query.log-static-assets-access + default_value: "false" + usage: Log when static assets are accessed (for debugging) + - name: query.max-clock-skew-adjustment + default_value: 0s + usage: | + The maximum delta by which span timestamps may be adjusted in the UI due to clock skew; set to 0s to disable clock skew adjustments + - name: query.static-files + usage: The directory path override for the static assets for the UI + - name: query.ui-config + usage: The path to the UI configuration file in JSON format + - name: span-storage.type + usage: | + (deprecated) please use SPAN_STORAGE_TYPE environment variable. Run this binary with the 'env' command for help. +see_also: + - jaeger-query completion - Generate the autocompletion script for the specified shell + - jaeger-query docs - Generates documentation + - jaeger-query env - Help about environment variables. + - jaeger-query print-config - Print names and values of configuration options + - jaeger-query status - Print the status. + - jaeger-query version - Print the version. diff --git a/data/cli/1.61/jaeger-query_completion.yaml b/data/cli/1.61/jaeger-query_completion.yaml new file mode 100644 index 00000000..ec469e94 --- /dev/null +++ b/data/cli/1.61/jaeger-query_completion.yaml @@ -0,0 +1,16 @@ +name: jaeger-query completion +synopsis: Generate the autocompletion script for the specified shell +description: | + Generate the autocompletion script for jaeger-query for the specified shell. + See each sub-command's help for details on how to use the generated script. +options: + - name: help + shorthand: h + default_value: "false" + usage: help for completion +see_also: + - jaeger-query - Jaeger query service provides a Web UI and an API for accessing trace data. + - jaeger-query completion bash - Generate the autocompletion script for bash + - jaeger-query completion fish - Generate the autocompletion script for fish + - jaeger-query completion powershell - Generate the autocompletion script for powershell + - jaeger-query completion zsh - Generate the autocompletion script for zsh diff --git a/data/cli/1.61/jaeger-query_docs.yaml b/data/cli/1.61/jaeger-query_docs.yaml new file mode 100644 index 00000000..3fecfb71 --- /dev/null +++ b/data/cli/1.61/jaeger-query_docs.yaml @@ -0,0 +1,17 @@ +name: jaeger-query docs +synopsis: Generates documentation +description: Generates command and flags documentation +usage: jaeger-query docs [flags] +options: + - name: dir + default_value: ./ + usage: Directory where generate the documentation. + - name: format + default_value: md + usage: 'Supported formats: [md man rst yaml].' + - name: help + shorthand: h + default_value: "false" + usage: help for docs +see_also: + - jaeger-query - Jaeger query service provides a Web UI and an API for accessing trace data. diff --git a/data/cli/1.61/jaeger-query_env.yaml b/data/cli/1.61/jaeger-query_env.yaml new file mode 100644 index 00000000..134900d2 --- /dev/null +++ b/data/cli/1.61/jaeger-query_env.yaml @@ -0,0 +1,11 @@ +name: jaeger-query env +synopsis: Help about environment variables. +description: "\nAll command line options can be provided via environment variables by converting\ntheir names to upper case and replacing punctuation with underscores. For example:\n\ncommand line option environment variable\n------------------------------------------------------------------\n--cassandra.connections-per-host CASSANDRA_CONNECTIONS_PER_HOST\n--metrics-backend METRICS_BACKEND\n\nThe following configuration options are only available via environment variables:\n\nSPAN_STORAGE_TYPE string The type of backend [cassandra, opensearch, elasticsearch, memory, kafka, badger, blackhole, grpc] used for trace storage. Multiple backends can be specified as comma-separated list, e.g. \"cassandra,elasticsearch\" (currently only for writing spans). Note that \"kafka\" is only valid in jaeger-collector; it is not a replacement for a proper storage backend, and only used as a buffer for spans when Jaeger is deployed in the collector+ingester configuration. (default \"cassandra\")\n\nDEPENDENCY_STORAGE_TYPE string The type of backend used for service dependencies storage. (default \"${SPAN_STORAGE_TYPE}\")\n\nSAMPLING_CONFIG_TYPE string The method [file, adaptive] used for determining the sampling rates served to clients configured with remote sampling enabled. \"file\" uses a periodically reloaded file and \"adaptive\" dynamically adjusts sampling rates based on current traffic. (default \"file\")\n\nSAMPLING_STORAGE_TYPE string The type of backend [cassandra, memory, badger] used for adaptive sampling storage when adaptive sampling is enabled via SAMPLING_CONFIG_TYPE. \n\nMETRICS_STORAGE_TYPE string The type of backend [prometheus] used as a metrics store with Service Performance Monitoring (https://www.jaegertracing.io/docs/latest/spm/). \n\n" +usage: jaeger-query env [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for env +see_also: + - jaeger-query - Jaeger query service provides a Web UI and an API for accessing trace data. diff --git a/data/cli/1.61/jaeger-query_print-config.yaml b/data/cli/1.61/jaeger-query_print-config.yaml new file mode 100644 index 00000000..3212a416 --- /dev/null +++ b/data/cli/1.61/jaeger-query_print-config.yaml @@ -0,0 +1,17 @@ +name: jaeger-query print-config +synopsis: Print names and values of configuration options +description: | + Print names and values of configuration options, distinguishing between default and user-assigned values +usage: jaeger-query print-config [flags] +options: + - name: all + shorthand: a + default_value: "false" + usage: | + Print all configuration options including those with empty values + - name: help + shorthand: h + default_value: "false" + usage: help for print-config +see_also: + - jaeger-query - Jaeger query service provides a Web UI and an API for accessing trace data. diff --git a/data/cli/1.61/jaeger-query_status.yaml b/data/cli/1.61/jaeger-query_status.yaml new file mode 100644 index 00000000..43ec303a --- /dev/null +++ b/data/cli/1.61/jaeger-query_status.yaml @@ -0,0 +1,16 @@ +name: jaeger-query status +synopsis: Print the status. +description: | + Print Jaeger component status information, exit non-zero on any error. +usage: jaeger-query status [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for status + - name: status.http.host-port + default_value: :16687 + usage: | + The host:port (e.g. 127.0.0.1:16687 or :16687) for the health check +see_also: + - jaeger-query - Jaeger query service provides a Web UI and an API for accessing trace data. diff --git a/data/cli/1.61/jaeger-query_version.yaml b/data/cli/1.61/jaeger-query_version.yaml new file mode 100644 index 00000000..fb5c01cb --- /dev/null +++ b/data/cli/1.61/jaeger-query_version.yaml @@ -0,0 +1,11 @@ +name: jaeger-query version +synopsis: Print the version. +description: Print the version and build information. +usage: jaeger-query version [flags] +options: + - name: help + shorthand: h + default_value: "false" + usage: help for version +see_also: + - jaeger-query - Jaeger query service provides a Web UI and an API for accessing trace data. From cee94fe4d2720227c23b08c5a3e095a62524a0bd Mon Sep 17 00:00:00 2001 From: Yuri Shkuro Date: Sun, 15 Sep 2024 08:10:36 -0400 Subject: [PATCH 3/4] Mention v2 artifacts and docs (#738) --- content/download/_index.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/content/download/_index.md b/content/download/_index.md index de06797b..59a2570b 100644 --- a/content/download/_index.md +++ b/content/download/_index.md @@ -7,6 +7,10 @@ Jaeger components can be downloaded in two ways: * As [executable binaries](#binaries) * As [Docker images](#docker-images) +## Try Jaeger v2 + +The 2.x release candidate executable can be found in the latest [GitHub release](https://github.com/jaegertracing/jaeger/releases/) or as a Docker image `jaegertracing/jaeger` (https://hub.docker.com/r/jaegertracing/jaeger/tags). See also work in progress [v2 documentation](/docs/next-release-v2/). + ## Binaries Jaeger binaries are available for macOS, Linux, and Windows. The table below lists the available binaries: From e879666e520cb593d0706b63235060d22d0e78c4 Mon Sep 17 00:00:00 2001 From: Jonah Kowall Date: Mon, 16 Sep 2024 11:46:48 -0700 Subject: [PATCH 4/4] Some cleanups in docs (#739) ## Description of the changes Some small improvements for v2 docs ## Checklist - [X] I have read https://github.com/jaegertracing/jaeger/blob/master/CONTRIBUTING_GUIDELINES.md - [X] I have signed all commits --------- Signed-off-by: Jonah Kowall --- content/docs/next-release-v2/badger.md | 13 +-- content/docs/next-release-v2/cassandra.md | 18 +--- content/docs/next-release-v2/elasticsearch.md | 16 +-- content/docs/next-release-v2/faq.md | 4 +- .../docs/next-release-v2/getting-started.md | 4 +- content/docs/next-release-v2/kafka.md | 26 ++--- content/docs/next-release-v2/opensearch.md | 17 +--- content/docs/next-release-v2/sampling.md | 99 +++++++++++++++++++ content/docs/next-release-v2/storage.md | 10 +- 9 files changed, 116 insertions(+), 91 deletions(-) create mode 100644 content/docs/next-release-v2/sampling.md diff --git a/content/docs/next-release-v2/badger.md b/content/docs/next-release-v2/badger.md index 449fc566..1d4b80f0 100644 --- a/content/docs/next-release-v2/badger.md +++ b/content/docs/next-release-v2/badger.md @@ -5,18 +5,7 @@ hasparent: true [Badger](https://github.com/dgraph-io/badger) is an embedded local storage, only available with **all-in-one** distribution. By default, it acts as ephemeral storage using a temporary file system. -This can be overridden by using the `--badger.ephemeral=false` option. -```sh -docker run \ - -e SPAN_STORAGE_TYPE=badger \ - -e BADGER_EPHEMERAL=false \ - -e BADGER_DIRECTORY_VALUE=/badger/data \ - -e BADGER_DIRECTORY_KEY=/badger/key \ - -v :/badger \ - -p 16686:16686 \ - jaegertracing/all-in-one:{{< currentVersion >}} -``` +For [additional configuration](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/config-badger.yaml) -* [Upgrade Badger v1 to v3](https://github.com/jaegertracing/jaeger/blob/main/plugin/storage/badger/docs/upgrade-v1-to-v3.md) * [Badger file permissions as non-root service](https://github.com/jaegertracing/jaeger/blob/main/plugin/storage/badger/docs/storage-file-non-root-permission.md) diff --git a/content/docs/next-release-v2/cassandra.md b/content/docs/next-release-v2/cassandra.md index 8b075f49..586aae04 100644 --- a/content/docs/next-release-v2/cassandra.md +++ b/content/docs/next-release-v2/cassandra.md @@ -14,24 +14,8 @@ Cassandra also has the following officially supported resources available from t - [Kubernetes Operator](https://github.com/k8ssandra/cass-operator) from DataStax #### Configuration -##### Minimal -```sh -docker run \ - -e SPAN_STORAGE_TYPE=cassandra \ - -e CASSANDRA_SERVERS=<...> \ - jaegertracing/jaeger-collector:{{< currentVersion >}} -``` -Note: White space characters are allowed in `CASSANDRA_SERVERS`. For Example: Servers can be passed as `CASSANDRA_SERVERS="1.2.3.4, 5.6.7.8" for better readability. - -##### All options -To view the full list of configuration options, you can run the following command: -```sh -docker run \ - -e SPAN_STORAGE_TYPE=cassandra \ - jaegertracing/jaeger-collector:{{< currentVersion >}} \ - --help -``` +Configuration example for [Jaeger writing to Cassandra](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/config-cassandra.yaml). #### Schema script diff --git a/content/docs/next-release-v2/elasticsearch.md b/content/docs/next-release-v2/elasticsearch.md index f1417d17..de351169 100644 --- a/content/docs/next-release-v2/elasticsearch.md +++ b/content/docs/next-release-v2/elasticsearch.md @@ -21,22 +21,8 @@ ElasticSearch also has the following officially supported resources available fr - [Kubernetes Operator](https://github.com/openshift/elasticsearch-operator) from RedHat #### Configuration -##### Minimal -```sh -docker run \ - -e SPAN_STORAGE_TYPE=elasticsearch \ - -e ES_SERVER_URLS=<...> \ - jaegertracing/jaeger-collector:{{< currentVersion >}} -``` -##### All options -To view the full list of configuration options, you can run the following command: -```sh -docker run \ - -e SPAN_STORAGE_TYPE=elasticsearch \ - jaegertracing/jaeger-collector:{{< currentVersion >}} \ - --help -``` +Here is [example configuration](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/config-elasticsearch.yaml) for ElasticSearch. #### Shards and Replicas for Elasticsearch indices diff --git a/content/docs/next-release-v2/faq.md b/content/docs/next-release-v2/faq.md index 3aa8e7c3..e385a85d 100644 --- a/content/docs/next-release-v2/faq.md +++ b/content/docs/next-release-v2/faq.md @@ -7,7 +7,7 @@ weight: 7 ## Why is the Dependencies page empty? -The Dependencies page shows a graph of services traced by Jaeger and connections between them. When you are using `all-in-one` binary with in-memory storage, the graph is calculated on-demand from all the traces stored in memory. However, if you are using real distributed storage like Cassandra or OpenSearch/Elasticsearch, it is too expensive to scan all the data in the database to build the service graph. Instead, the Jaeger project provides "big data" jobs that can be used to extract the service graph data from traces: +The Dependencies page shows a graph of services traced by Jaeger and connections between them. When you are using in-memory storage, the graph is calculated on-demand from all the traces stored in memory. However, if you are using real distributed storage like Cassandra, Elasticsearch, or OpenSearch it is too expensive to scan all the data in the database to build the service graph. Instead, the Jaeger project provides "big data" jobs that can be used to extract the service graph data from traces: * https://github.com/jaegertracing/spark-dependencies - the older Spark job that can be run periodically * https://github.com/jaegertracing/jaeger-analytics - the new (experimental) streaming Flink jobs that run continuously and builds the service graph in smaller time intervals @@ -18,7 +18,7 @@ Please refer to the [Troubleshooting](../troubleshooting/) guide. ## What is the recommended storage backend? -The Jaeger team recommends OpenSearch/Elasticsearch as the storage backend over Cassandra, for the following reasons: +The Jaeger team recommends Elasticsearch or OpenSearch as the storage backend over Cassandra, for the following reasons: * Cassandra is a key-value database, so it is more efficient for retrieving traces by trace ID, but it does not provide the same powerful search capabilities as OpenSearch. Effectively, the Jaeger backend implements the search functionality on the client side, on top of k-v storage, which is limited and may produce inconsistent results (see [issue-166][issue-166] for more details). OpenSearch does not suffer from these issues, resulting in better usability. OpenSearch can also be queried directly, e.g. from Kibana dashboards, and provide useful analytics and aggregations. diff --git a/content/docs/next-release-v2/getting-started.md b/content/docs/next-release-v2/getting-started.md index 437e09bd..0c16efb8 100644 --- a/content/docs/next-release-v2/getting-started.md +++ b/content/docs/next-release-v2/getting-started.md @@ -16,7 +16,7 @@ The Jaeger SDKs are no longer supported, and all users must migrate to OpenTelem **jaeger** is a single binary which can serve multiple purposes. It has a configuration embedded which provides full functionality for testing with an in memory storage component. If you would like to change the configuration you may create a YAML configuration file. -Run the `jaeger-all-in-one(.exe)` executable from the [binary distribution archives][download]: +Run the `jaeger(.exe)` executable from the [binary distribution archives][download]: ```bash jaeger @@ -116,7 +116,7 @@ Then navigate to `http://localhost:8080`. ## Migrating from Zipkin -**jaeger-collector** service exposes Zipkin compatible REST API `/api/v1/spans` which accepts both Thrift and JSON. Also there is `/api/v2/spans` for JSON and Proto. +The **jaeger collector role** service exposes Zipkin compatible REST API `/api/v1/spans` which accepts both Thrift and JSON. Also there is `/api/v2/spans` for JSON and Proto. By default it's disabled. It can be enabled with `--collector.zipkin.host-port=:9411`. Zipkin [Thrift](https://github.com/jaegertracing/jaeger-idl/blob/master/thrift/zipkincore.thrift) IDL and Zipkin [Proto](https://github.com/jaegertracing/jaeger-idl/blob/master/proto/zipkin.proto) IDL files can be found in [jaegertracing/jaeger-idl](https://github.com/jaegertracing/jaeger-idl) repository. diff --git a/content/docs/next-release-v2/kafka.md b/content/docs/next-release-v2/kafka.md index 8942d31e..f8b73e98 100644 --- a/content/docs/next-release-v2/kafka.md +++ b/content/docs/next-release-v2/kafka.md @@ -7,9 +7,7 @@ hasparent: true * Supported Kafka versions: 0.9+ Kafka can be used as an intermediary buffer between collector and an actual storage. -**jaeger-collector** is configured with `SPAN_STORAGE_TYPE=kafka` that makes it write all received spans -into a Kafka topic. [**jaeger-ingester**](#ingester) is used to read from -Kafka and store spans in another storage backend (Elasticsearch or Cassandra). +**jaeger** can be configured to both act as the `collector` for Kafka data before adding it to a Kafka topic and also as a `ingester` to get data from Kafka and forward it to another storage backend. Writing to Kafka is particularly useful for building post-processing data pipelines. @@ -19,23 +17,11 @@ Kafka also has the following officially supported resources available from the c - [Strimzi Kubernetes Operator](https://strimzi.io/) #### Configuration -##### Minimal -```sh -docker run \ - -e SPAN_STORAGE_TYPE=kafka \ - -e KAFKA_PRODUCER_BROKERS=<...> \ - -e KAFKA_TOPIC=<...> \ - jaegertracing/jaeger-collector:{{< currentVersion >}} -``` - -##### All options -To view the full list of configuration options, you can run the following command: -```sh -docker run \ - -e SPAN_STORAGE_TYPE=kafka \ - jaegertracing/jaeger-collector:{{< currentVersion >}} \ - --help -``` +##### Collector +In order to collect tracing data and add it to a Kafka topic this [configuration](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/config-kafka-collector.yaml) is what should be used. + +##### Ingester +In order to write tracing data which is added to a Kafka topic this [configuration](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/config-kafka-ingester.yaml) is what should be used. #### Topic & partitions Unless your Kafka cluster is configured to automatically create topics, you will need to create it ahead of time. You can refer to [the Kafka quickstart documentation](https://kafka.apache.org/documentation/#quickstart_createtopic) to learn how. diff --git a/content/docs/next-release-v2/opensearch.md b/content/docs/next-release-v2/opensearch.md index bdc8d0fc..a44d7cfc 100644 --- a/content/docs/next-release-v2/opensearch.md +++ b/content/docs/next-release-v2/opensearch.md @@ -19,22 +19,9 @@ OpenSearch also has the following officially supported resources available from - [Kubernetes Operator](https://github.com/opensearch-project/opensearch-k8s-operator) #### Configuration -##### Minimal -```sh -docker run \ - -e SPAN_STORAGE_TYPE=elasticsearch \ - -e ES_SERVER_URLS=<...> \ - jaegertracing/jaeger-collector:{{< currentVersion >}} -``` -##### All options -To view the full list of configuration options, you can run the following command: -```sh -docker run \ - -e SPAN_STORAGE_TYPE=elasticsearch \ - jaegertracing/jaeger-collector:{{< currentVersion >}} \ - --help -``` +Here is [example configuration](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/config-opensearch.yaml) for OpenSearch. + #### Shards and Replicas for OpenSearch indices diff --git a/content/docs/next-release-v2/sampling.md b/content/docs/next-release-v2/sampling.md new file mode 100644 index 00000000..ce68d84c --- /dev/null +++ b/content/docs/next-release-v2/sampling.md @@ -0,0 +1,99 @@ +--- +title: Sampling +hasparent: true +--- + +Sampling is essential when handling large volumes of traces. Ideally, discarding less interesting data and keeping the data needed to diagnose issues. Other capabilities like calculating metrics from traces can help reduce the volume of spans collected and stored. + +Jaeger supports multiple types of sampling strategies which leverage OpenTelemetry. The `jaeger` binary supports specific configurations. + +## Head Based Sampling +Head based sampling is when the sampling decision is made when the first spans are seen by `jaeger`. The support of Head based sampling comes from OpenTelemetry. The topic is covered in the [OpenTelemetry documentation on head based sampling](https://opentelemetry.io/docs/concepts/sampling/#head-sampling). + +Example configuration for [various head based sampling strategies](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/sampling-strategies.json). + +## Tail Based Sampling +Tail based sampling allows for the sampling decisions to be made after the trace is complete and all spans have been collected. Ideally this provides more granular control over which traces and kept and which are discarded. The downside to this is that more memory and processing power will be used by `jaeger` binaries. + +This [configuration allows for the sampling of everything observed](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/config-tail-sampling-always-sample.yaml) by `jaeger` with debug logging to diagnose problems. + +The second configuration of `jaeger` [samples for a specific service name](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/config-tail-sampling-service-name-policy.yaml). + +## Remote Sampling + +If your client SDKs are configured to use remote sampling configuration (see [Remote Sampling API][remote-sampling-api]) then sampling rates can be centrally controlled. In this setup a sampling strategy configuration is served to the client SDK that describes endpoints and their sampling probabilities. This configuration can be generated by `jaeger` in two different ways: [periodically loaded from a file](#file-based-sampling-configuration) or [dynamically calculated based on traffic](#adaptive-sampling). The method of generation is controlled by the environment variable `SAMPLING_CONFIG_TYPE` which can be set to either `file` (default) or `adaptive`. + +[remote-sampling-api]: ../apis#remote-sampling-configuration-stable + +### File-based Sampling Configuration + +`jaeger` can be instantiated with the `--sampling.strategies-file` option that points to a file containing sampling strategies to be served to Jaeger clients. The option's value can contain a path to a JSON file, which will be automatically reloaded if its contents change, or an HTTP URL from where the file will be periodically retrieved, with reload frequency controlled by the `--sampling.strategies-reload-interval` option. + +If no configuration is provided, **jaeger-collector**s will return the default probabilistic sampling policy with probability 0.001 (0.1%) for all services. + +Example `strategies.json`: +```json +{ + "service_strategies": [ + { + "service": "foo", + "type": "probabilistic", + "param": 0.8, + "operation_strategies": [ + { + "operation": "op1", + "type": "probabilistic", + "param": 0.2 + }, + { + "operation": "op2", + "type": "probabilistic", + "param": 0.4 + } + ] + }, + { + "service": "bar", + "type": "ratelimiting", + "param": 5 + } + ], + "default_strategy": { + "type": "probabilistic", + "param": 0.5, + "operation_strategies": [ + { + "operation": "/health", + "type": "probabilistic", + "param": 0.0 + }, + { + "operation": "/metrics", + "type": "probabilistic", + "param": 0.0 + } + ] + } +} +``` + +`service_strategies` element defines service specific sampling strategies and `operation_strategies` defines operation specific sampling strategies. There are 2 types of strategies possible: `probabilistic` and `ratelimiting` which are described [above](#client-sampling-configuration) (NOTE: `ratelimiting` is not supported for `operation_strategies`). `default_strategy` defines the catch-all sampling strategy that is propagated if the service is not included as part of `service_strategies`. + +In the above example: + +* All operations of service `foo` are sampled with probability 0.8 except for operations `op1` and `op2` which are probabilistically sampled with probabilities 0.2 and 0.4 respectively. +* All operations for service `bar` are rate-limited at 5 traces per second. +* Any other service will be sampled with probability 0.5 defined by the `default_strategy`. +* The `default_strategy` also includes shared per-operation strategies. In this example we disable tracing on `/health` and `/metrics` endpoints for all services by using probability 0. These per-operation strategies will apply to any new service not listed in the config, as well as to the `foo` and `bar` services unless they define their own strategies for these two operations. + +### Adaptive Sampling + +Since Jaeger v1.27. + +Adaptive sampling works in **jaeger-collector** by observing the spans received from services and recalculating sampling probabilities for each service/endpoint combination to ensure that the volume of collected traces matches `--sampling.target-samples-per-second`. When a new service or endpoint is detected, it is initially sampled with `--sampling.initial-sampling-probability` until enough data is collected to calculate the rate appropriate for the traffic going through the endpoint. + +Adaptive sampling requires a storage backend to store the observed traffic data and computed probabilities. At the moment `memory` (for all-in-one deployment), `cassandra`, `badger`, `elasticsearch` and `opensearch` are supported as sampling storage backends. + +By default adaptive sampling will attempt to use the backend specified by `SPAN_STORAGE_TYPE` to store data. However, a second type of backend can also be specified by using `SAMPLING_STORAGE_TYPE`. For instance, `SPAN_STORAGE_TYPE=elasticsearch SAMPLING_STORAGE_TYPE=cassandra ./jaeger-collector` will run **jaeger-collector** in a mode where it attempts to store its span data in the configured elasticsearch cluster and its adaptive sampling data in the configured cassandra cluster. Note that this feature can not be used to store span and adaptive sampling data in two different backends of the same type. + +Read [this blog post](https://medium.com/jaegertracing/adaptive-sampling-in-jaeger-50f336f4334) for more details on adaptive sampling engine. diff --git a/content/docs/next-release-v2/storage.md b/content/docs/next-release-v2/storage.md index cc6d9070..2ab0f326 100644 --- a/content/docs/next-release-v2/storage.md +++ b/content/docs/next-release-v2/storage.md @@ -18,7 +18,7 @@ children: url: metrics.md --- -Jaeger requires a persistent storage backend. Cassandra and Elasticsearch/OpenSearch are the primary supported distributed storage backends. Additional backends are [discussed here](https://github.com/jaegertracing/jaeger/issues/638). +Jaeger requires a persistent storage backend. Cassandra, Elasticsearch, and OpenSearch are the primary supported distributed storage backends. Additional backends are [discussed here](https://github.com/jaegertracing/jaeger/issues/638). The storage type can be passed via `SPAN_STORAGE_TYPE` environment variable. Valid values are `cassandra`, `elasticsearch`, `kafka` (only as a buffer), `badger` and `memory`. @@ -32,13 +32,7 @@ Jaeger supports a gRPC-based [Remote Storage API][storage.proto] that allows ext To use a remote storage as Jaeger storage backend, use `grpc` as the storage type and specify the remote gRPC server address. For more information, please refer to [jaeger/plugin/storage/grpc](https://github.com/jaegertracing/jaeger/tree/master/plugin/storage/grpc). -Example: -```sh -docker run \ - -e SPAN_STORAGE_TYPE=grpc \ - -e GRPC_STORAGE_SERVER=<...> \ - jaegertracing/all-in-one:{{< currentVersion >}} -``` +Example config for `jaeger` [can be found here](https://github.com/jaegertracing/jaeger/blob/main/cmd/jaeger/config-remote-storage.yaml). Known remote storage backends: