From fc5c860b8e462a23b237de639077da7cd4fd0fde Mon Sep 17 00:00:00 2001 From: Tigran Najaryan <4194920+tigrannajaryan@users.noreply.github.com> Date: Tue, 29 Oct 2019 16:23:55 -0400 Subject: [PATCH] Add OpenTelemetry Protocol (OTLP) RFC (#35) * Add OTLP Draft RFC OpenTelemetry Protocol (OTLP) specification describes the encoding, transport and delivery mechanism of telemetry data between telemetry sources, intermediate nodes such as collectors and telemetry backends. * PR fixes * Make Unary gRPC the only recommended mode Experiments have shown that Streaming implementation results in significantly more complex code. The performance benefits of Streaming mode were only visible in very small batches and are not applicable to real life scenarios when under high load we aim to have large batches. In addition, one of the potential benefits that we could get with Streaming - the ability to optimize and avoid repetition of Resource does not seem to have much real life usage. As a result Streaming mode was removed from the RFC and Unary mode is the only mode that is now part of the spec. * Address review comments * Change status to approved * Address review comments --- text/0035-opentelemetry-protocol.md | 429 +++++++++++++++++++++++++ text/images/otlp-client-server.png | Bin 0 -> 10256 bytes text/images/otlp-concurrent.png | Bin 0 -> 9983 bytes text/images/otlp-multi-destination.png | Bin 0 -> 24900 bytes text/images/otlp-request-response.png | Bin 0 -> 22919 bytes text/images/otlp-sequential.png | Bin 0 -> 11665 bytes 6 files changed, 429 insertions(+) create mode 100644 text/0035-opentelemetry-protocol.md create mode 100644 text/images/otlp-client-server.png create mode 100644 text/images/otlp-concurrent.png create mode 100644 text/images/otlp-multi-destination.png create mode 100644 text/images/otlp-request-response.png create mode 100644 text/images/otlp-sequential.png diff --git a/text/0035-opentelemetry-protocol.md b/text/0035-opentelemetry-protocol.md new file mode 100644 index 000000000..fadec8307 --- /dev/null +++ b/text/0035-opentelemetry-protocol.md @@ -0,0 +1,429 @@ +# OpenTelemetry Protocol Specification + +_Author: Tigran Najaryan, Omnition Inc._ + +**Status:** `approved` + +OpenTelemetry Protocol (OTLP) specification describes the encoding, transport and delivery mechanism of telemetry data between telemetry sources, intermediate nodes such as collectors and telemetry backends. + +## Table of Contents + + - [Motivation](#motivation) + - [Protocol Details](#protocol-details) + - [Export Request and Response](#export-request-and-response) + - [OTLP over gRPC](#otlp-over-grpc) + - [Result Code](#result-code) + - [Throttling](#throttling) + - [gRPC Service Definition](#grpc-service-definition) + - [Other Transports](#other-transports) + - [Implementation Recommendations](#implementation-recommendations) + - [Multi-Destination Exporting](#multi-destination-exporting) + - [Trade-offs and mitigations](#trade-offs-and-mitigations) + - [Request Acknowledgements](#request-acknowledgements) + - [Duplicate Data](#duplicate-data) + - [Partial Success](#partial-success) + - [Future Versions and Interoperability](#future-versions-and-interoperability) + - [Prior Art, Alternatives and Future Possibilities](#prior-art-alternatives-and-future-possibilities) + - [Open Questions](#open-questions) + - [Appendix A - Protocol Buffer Definitions](#appendix-a---protocol-buffer-definitions) + - [Appendix B - Performance Benchmarks](#appendix-b---performance-benchmarks) + - [Throughput - Sequential vs Concurrent](#throughput---sequential-vs-concurrent) + - [CPU Usage - gRPC vs WebSocket/Experimental](#cpu-usage---grpc-vs-websocketexperimental) + - [Benchmarking Raw Results](#benchmarking-raw-results) + - [Glossary](#glossary) + - [Acknowledgements](#acknowledgements) + + +## Motivation + +OTLP is a general-purpose telemetry data delivery protocol designed in the scope of OpenTelemetry project. It is an incremental improvement of OpenCensus protocol. Compared to OpenCensus protocol OTLP has the following improvements: + +- Ensures high reliability of data delivery and clear visibility when the data cannot be delivered. OTLP uses acknowledgements to implement reliable delivery. + +- It is friendly to Level 7 Load Balancers and allows them to correctly map imbalanced incoming traffic to a balanced outgoing traffic. This allows to efficiently operate large networks of nodes where telemetry data generation rates change over time. + +- Allows backpressure signalling from telemetry data destinations to sources. This is important for implementing reliable multi-hop telemetry data delivery all the way from the source to the destination via intermediate nodes, each having different processing capacity and thus requiring different data transfer rates. + +## Protocol Details + +OTLP defines the encoding of telemetry data and the protocol used to exchange data between the client and the server. + +This specification defines how OTLP is implemented over [gRPC](https://grpc.io/) and specifies corresponding [Protocol Buffers](https://developers.google.com/protocol-buffers/docs/overview) schema. Future extensions to OTLP may define implementations over other transports. For details of gRPC service definition see section [gRPC Transport](#grpc-transport). + +OTLP is a request/response style protocols: the clients send requests, the server replies with corresponding responses. This document defines one requests and response type: `Export`. + +### Export Request and Response + +After establishing the underlying transport the client starts sending telemetry data using `Export` requests. The client continuously sends a sequence of `Export` requests to the server and expects to receive a response to each request: + +![Request-Response](images/otlp-request-response.png) + +_Note: this protocol is concerned with reliability of delivery between one pair of client/server nodes and aims to ensure that no data is lost in-transit between the client and the server. Many telemetry collection systems have intermediary nodes that the data must travel across until reaching the final destination (e.g. application -> agent -> collector -> backend). End-to-end delivery guarantees in such systems is outside of the scope of OTLP. The acknowledgements described in this protocol happen between a single client/server pair and do not span intermediary nodes in multi-hop delivery paths._ + +#### OTLP over gRPC + +For gRPC transport OTLP uses Unary RPC to send export requests and receives responses. + +After sending the request the client MAY wait until the response is received from the server. In that case there will be at most only one request in flight that is not yet acknowledged by the server. + +![Unary](images/otlp-sequential.png) + +Sequential operation is recommended when simplicity of implementation is desirable and when the client and the server are connected via very low-latency network, such as for example when the client is an instrumented application and the server is a OpenTelemetry Service running as a local daemon. + +The implementations that need to achieve high throughput SHOULD support concurrent Unary calls to achieve higher throughput. The client SHOULD send new requests without waiting for the response to the earlier sent requests, essentially creating a pipeline of requests that are currently in flight that are not acknowledged. + +![Streaming](images/otlp-concurrent.png) + +The number of concurrent requests SHOULD be configurable. + +The maximum achievable throughput is `max_concurrent_requests * max_request_size / (network_latency + server_response_time)`. For example if the request can contain at most 100 spans, network roundtrip latency is 200ms and server response time is 300 ms, then the maximum achievable throughput with one concurrent request is `100 spans / (200ms+300ms)` or 200 spans per second. It is easy to see that in high latency networks or when the server response time is high to achieve good throughput the requests need to be very big or a lot concurrent requests must be done. + +If the client is shutting down (e.g. when the containing process wants to exit) the client will optionally wait until all pending acknowledgements are received or until an implementation specific timeout expires. This ensures reliable delivery of telemetry data. The client implementation SHOULD expose an option to turn on and off the waiting during shutdown. + +If the client is unable to deliver a certain request (e.g. a timer expired while waiting for acknowledgements) the client SHOULD record the fact that the data was not delivered. + +#### Result Code + +`Export` response includes a `result_code` field, which indicates whether the server was able to successfully process the received data. Possible values for `result_code` field are: + +- `Success` - telemetry data is successfully processed by the server. If the server receives an empty request (a request that does not carry any telemetry data) the server SHOULD respond with `Success`. + +- `FailedNotRetryable` - processing of telemetry data failed. The client MUST NOT retry sending the same telemetry data. The telemetry data MUST be dropped. This for example can happen when the request contains bad data and cannot be deserialized or otherwise processed by the server. The client SHOULD maintain a counter of such dropped data. + +- `FailedRetryable` - processing of telemetry data failed. The client SHOULD record the error and may retry exporting the same data immediately. This can happen when the server is temporarily unable to process the data. + +#### Throttling + +OTLP allows backpressure signalling. + +If the server is unable to keep up with the pace of data it receives from the client then it SHOULD signal that fact to the client. The client MUST then throttle itself to avoid overwhelming the server. + +To signal backpressure when using gRPC transport the server SHOULD return an error with code [Unavailable](https://godoc.org/google.golang.org/grpc/codes) and MAY supply additional [details via status](https://godoc.org/google.golang.org/grpc/status#Status.WithDetails) using [RetryInfo](https://github.com/googleapis/googleapis/blob/master/google/rpc/error_details.proto#L40). Here is a sample Go code to illustrate: + +```go + // Do this on server side. + st, err := status.New(codes.Unavailable, "Server is unavailable"). + WithDetails(&errdetails.RetryInfo{RetryDelay: &duration.Duration{Seconds: 30}}) + if err != nil { + log.Fatal(err) + } + + return st.Err() + + ... + + // Do this on client side. + st := status.Convert(err) + for _, detail := range st.Details() { + switch t := detail.(type) { + case *errdetails.RetryInfo: + if t.RetryDelay.Seconds > 0 || t.RetryDelay.Nanos > 0 { + // Wait before retrying. + } + } + } +``` + +When the client receives this signal it SHOULD follow the recommendations outlined in documentation for `RetryInfo`: + +``` +// Describes when the clients can retry a failed request. Clients could ignore +// the recommendation here or retry when this information is missing from error +// responses. +// +// It's always recommended that clients should use exponential backoff when +// retrying. +// +// Clients should wait until `retry_delay` amount of time has passed since +// receiving the error response before retrying. If retrying requests also +// fail, clients should use an exponential backoff scheme to gradually increase +// the delay between retries based on `retry_delay`, until either a maximum +// number of retires have been reached or a maximum retry delay cap has been +// reached. +``` + +The value of `retry_delay` is determined by the server and is implementation dependant. The server SHOULD choose a `retry_delay` value that is big enough to give the server time to recover, yet is not too big to cause the client to drop data while it is throttled. + +#### gRPC Service Definition + +`Export` requests and responses are delivered using unary gRPC calls. + +This is OTLP over gRPC Service definition: + +``` +service UnaryExporter { + rpc ExportTraces(TraceExportRequest) returns (ExportResponse) {} + rpc ExportMetrics(MetricExportRequest) returns (ExportResponse) {} +} +``` + +Appendix A contains Protocol Buffer definitions for `TraceExportRequest`, `MetricExportRequest` and `ExportResponse`. + +### Other Transports + +OTLP can work over any other transport that supports message request/response capabilities. Additional transports supported by OTLP can be specified in future RFCs that extend OTLP. + +## Implementation Recommendations + +### Multi-Destination Exporting + +When the telemetry data from one client must be sent to more than one destination server there is an additional complication that must be accounted for. When one of the servers acknowledges the data and the other server does not (yet) acknowledges the client needs to make a decision about how to move forward. + +In such situation the the client SHOULD implement queuing, acknowledgement handling and retrying logic per destination. This ensures that servers do not block each other. The queues SHOULD reference shared, immutable data to be sent, thus minimizing the memory overhead caused by having multiple queues. + +![Multi-Destination Exporting](images/otlp-multi-destination.png) + +This ensures that all destination servers receive the data regardless of their speed of reception (within the available limits imposed by the size of the client-side queue). + +## Trade-offs and mitigations + +### Request Acknowledgements + +#### Duplicate Data + +In edge cases (e.g. on reconnections, network interruptions, etc) the client has no way of knowing if recently sent data was delivered if no acknowledgement was received yet. The client will typically choose to re-send such data to guarantee delivery, which may result in duplicate data on the server side. This is a deliberate choice and is considered to be the right tradeoff for telemetry data. + +### Partial Success + +The protocol does not attempt to communicate partial reception success from the server to the client (i.e. when part of the data can be received by the server and part of it cannot). Attempting to do so would complicate the protocol and implementations significantly and is left out as a possible future area of work. + +## Future Versions and Interoperability + +OTLP will evolve and change over time. Future versions of OTLP must be designed and implemented in a way that ensures that clients and servers that implement different versions of OTLP can interoperate and exchange telemetry data. Old clients must be able to talk to new servers and vice versa. If new versions of OTLP introduce new functionality that cannot be understood and supported by nodes implementing the old versions of OTLP the protocol must regress to the lowest common denominator from functional perspective. + +When possible the interoperability SHOULD be ensured between all versions of OTLP that are not declared obsolete. + +OTLP does not use explicit protocol version numbering. OTLP's interoperability of clients and servers of different versions is based on the following concepts: + +1. OTLP (current and future versions) defines a set of capabilities, some of which are mandatory, others are optional. Clients and servers must implement mandatory capabilities and can choose implement only a subset of optional capabilities. + +2. For minor changes to the protocol future versions and extension of OTLP are encouraged to use the ability of Protocol Buffers to evolve message schema in backwards compatible manner. Newer versions of OTLP may add new fields to messages that will be ignored by clients and servers that do not understand these fields. In many cases careful design of such schema changes and correct choice of default values for new fields is enough to ensure interoperability of different versions without nodes explicitly detecting that their peer node has different capabilities. + +3. More significant changes must be explicitly defined as new optional capabilities in future RFCs. Such capabilities SHOULD be discovered by client and server implementations after establishing the underlying transport. The exact discovery mechanism SHOULD be described in future RFCs which define the new capabilities and typically can be implemented by making a discovery request/response message exchange from the client to server. The mandatory capabilities defined by this specification are implied and do not require a discovery. The implementation which supports a new, optional capability MUST adjust its behavior to match the expectation of a peer that does not support a particular capability. + +The current version of OTLP is the initial version that describes mandatory capabilities only. Implementations of this specification SHOULD NOT attempt to detect the capabilities of their peers and should operate as defined in this document. + +## Prior Art, Alternatives and Future Possibilities + +We have considered using gRPC streaming instead of Unary RPC calls. This would require implementations to manually perform stream closing and opening periodically to be L7 Load Balancer friendly. Reference implementation using gRPC Streaming has shown that it results in significantly more complex and error prone code without significant benefits. Because of this Unary RPC was chosen. + +OTLP is an evolution of OpenCensus protocol based on the research and testing of its modifications in production at Omnition. The modifications include changes to data formats (see RFC0059), use of Unary PRC and backpressure signaling capability. + +OTLP uses Protocol Buffers for data encoding. Two other encodings were considered as alternative approaches: FlatBuffers and Capnproto. Both alternatives were rejected. FlatBuffers was rejected because it lacks required functionality in all languages except C++, particularly lack of verification of decoded data and inability to mutate in-memory data. Capnproto was rejected because it is not yet considered production ready, the API is not yet stable and like FlatBuffers it lacks ability mutate in-memory data. + +Both FlatBuffers and Capnproto are worth to be re-evaluated for future versions of OpenTelemetry protocol if they overcome currently known limitations. + +It is also worth researching transports other than gRPC. Other transports are not included in this RFC due to time limitations. + +Experimental implementation of OTLP over WebSockets exists and was researched as an alternate. WebSockets were not chosen as the primary transport for OTLP due to lack or immaturity of certain capabilities (such as [lack of universal support](https://github.com/gorilla/websocket#gorilla-websocket-compared-with-other-packages) for [RFC 7692](https://tools.ietf.org/html/rfc7692) message compression extension). Despite limitations the experimental implementation demonstrated good performance and WebSocket transport will be considered for inclusion in a future OTLP Extensions RFC. + +## Open Questions + +One of the goals for telemetry protocol is reducing CPU usage and memory pressure in garbage collected languages. These goals were not addressed as part of this RFC and remain open. One of the promising future ways to address this is finding a more CPU and memory efficient encoding mechanism. + +Another goal for telemetry protocol is achieving high compression ratios for telemetry data while keeping CPU consumption low. OTLP uses compression provided by gRPC transport. No further improvements to compression were considered as part of this RFC and are a future area of work. + +## Appendix A - Protocol Buffer Definitions + +This is Protocol Buffers schema for `Export` request and response: + +``` +// A request from client to server containing trace data to export. +message TraceExportRequest { + // Telemetry data. An array of ResourceSpans. + repeated ResourceSpans resourceSpans = 2; +} + +// A request from client to server containing metric data to export. +message MetricExportRequest { + // Telemetry data. An array of ResourceMetrics. + repeated ResourceMetrics resourceMetrics = 2; +} + +// A response to ExportRequest. +message ExportResponse { + enum ResultCode { + // Telemetry data is successfully processed by the server. + Success = 0; + + // processing of telemetry data failed. The client MUST NOT retry + // sending the same telemetry data. The telemetry data MUST be dropped. + // This for example can happen when the request contains bad data and + // cannot be deserialized or otherwise processed by the server. + FailedNotRetryable = 1; + + // Processing of telemetry data failed. The client SHOULD record the + // error and may retry exporting the same data after some time. This + // for example can happen when the server is overloaded. + FailedRetryable = 2; + } + ResultCode result_code = 2; +} + +// A list of spans from a Resource. +message ResourceSpans { + Resource resource = 1; + repeated Span spans = 2; +} + +// A list of metrics from a Resource. +message ResourceMetrics { + Resource resource = 1; + repeated Metric metrics = 2; +} +``` + +`Span`, `Metric` and `Resource` schema definitions are defined in RFCNNNN (RFC number to be defined and linked from here). + +## Appendix B - Performance Benchmarks + +Benchmarking of OTLP vs other telemetry protocols was done using [reference implementation in Go](https://github.com/tigrannajaryan/exp-otelproto). + +### Throughput - Sequential vs Concurrent + +Using 20 concurrent requests shows the following throughput advantage in benchmarks compared to sequential for various values of network roundtrip latency: + +``` ++-----------+-----------------------+ ++ Latency | Concurrent/Sequential | ++ | Throughput Factor | ++-----------+-----------------------+ ++ 0.02 ms | 1.7 | ++ 2 ms | 2.1 | ++ 20 ms | 4.9 | ++ 200 ms | 6.9 | ++-----------+-----------------------+ +``` + +Benchmarking is done using Export requests each carrying 500 spans, each span containing 10 small attributes. + +### CPU Usage - gRPC vs WebSocket/Experimental + +Experimental implementation using WebSocket transport demonstrated about 30% less CPU usage on small batches compared to gRPC transport and about 7% less CPU usage on large batches. + +This shows that exploring different transports with less overhead is a promising future direction. + +### Benchmarking Raw Results + +The following is the benchmarking result, running on on a system with i7 7500U processor, 16 GB RAM. (Note that the benchmarking script sets "performance" CPU governor during execution and sets nice value of the process for more consistent results). + +``` +==================================================================================== +Legend: +GRPC/Stream/LBTimed/Sync - GRPC, streaming, load balancer friendly, close stream every 30 sec, with ack +GRPC/Stream/LBTimed/Async/N - OTLP Streaming. GRPC, N streams, load balancer friendly, close stream every 30 sec, with async ack +GRPC/Unary - OTLP Unary. One request per batch, load balancer friendly, with ack +GRPC/Unary/Async - GRPC, unary async request per batch, load balancer friendly, with ack +GRPC/OpenCensus - OpenCensus protocol, streaming, not load balancer friendly, without ack +GRPC/OpenCensusWithAck - OpenCensus-like protocol, streaming, not load balancer friendly, with ack +GRPC/Stream/NoLB - GRPC, streaming, not load balancer friendly, with ack +GRPC/Stream/LBAlways/Sync - GRPC, streaming, load balancer friendly, close stream after every batch, with ack +GRPC/Stream/LBSrv/Async - OTLP Streaming. Load balancer friendly, server closes stream every 30 sec or 1000 batches, with async ack +WebSocket/Stream/Sync - WebSocket, streaming, unknown load balancer friendliness, with sync ack +WebSocket/Stream/Async - WebSocket, streaming, unknown load balancer friendliness, with async ack +WebSocket/Stream/Async/zlib - WebSocket, streaming, unknown load balancer friendliness, with async ack, zlib compression + + +8000 small batches, 100 spans per batch, 4 attrs per span +GRPC/Stream/LBTimed/Async/1 800000 spans, CPU time 12.4 sec, wall time 5.3 sec, 645.7 batches/cpusec, 1510.0 batches/wallsec +GRPC/Stream/LBTimed/Async/10 800000 spans, CPU time 12.3 sec, wall time 3.9 sec, 650.9 batches/cpusec, 2058.4 batches/wallsec +GRPC/Unary 800000 spans, CPU time 15.3 sec, wall time 9.5 sec, 523.2 batches/cpusec, 840.0 batches/wallsec +GRPC/Unary/Async 800000 spans, CPU time 14.1 sec, wall time 4.0 sec, 565.8 batches/cpusec, 1986.3 batches/wallsec +GRPC/OpenCensus 800000 spans, CPU time 21.7 sec, wall time 10.6 sec, 368.7 batches/cpusec, 751.5 batches/wallsec +GRPC/OpenCensusWithAck 800000 spans, CPU time 23.4 sec, wall time 19.0 sec, 342.3 batches/cpusec, 420.8 batches/wallsec +GRPC/Stream/NoLB 800000 spans, CPU time 13.6 sec, wall time 9.4 sec, 588.2 batches/cpusec, 848.7 batches/wallsec +GRPC/Stream/LBAlways/Sync 800000 spans, CPU time 16.1 sec, wall time 10.0 sec, 495.7 batches/cpusec, 798.8 batches/wallsec +GRPC/Stream/LBTimed/Sync 800000 spans, CPU time 13.7 sec, wall time 9.5 sec, 585.7 batches/cpusec, 845.1 batches/wallsec +GRPC/Stream/LBSrv/Async 800000 spans, CPU time 12.7 sec, wall time 12.5 sec, 628.9 batches/cpusec, 639.8 batches/wallsec +WebSocket/Stream/Sync 800000 spans, CPU time 8.4 sec, wall time 8.3 sec, 949.0 batches/cpusec, 965.3 batches/wallsec +WebSocket/Stream/Async 800000 spans, CPU time 9.4 sec, wall time 5.4 sec, 852.0 batches/cpusec, 1492.0 batches/wallsec +WebSocket/Stream/Async/zlib 800000 spans, CPU time 23.3 sec, wall time 16.5 sec, 343.8 batches/cpusec, 484.0 batches/wallsec + +800 large batches, 500 spans per batch, 10 attrs per span +GRPC/Stream/LBTimed/Async/1 400000 spans, CPU time 11.4 sec, wall time 7.1 sec, 70.2 batches/cpusec, 113.1 batches/wallsec +GRPC/Stream/LBTimed/Async/10 400000 spans, CPU time 12.2 sec, wall time 5.8 sec, 65.8 batches/cpusec, 138.4 batches/wallsec +GRPC/Unary 400000 spans, CPU time 10.7 sec, wall time 9.6 sec, 74.7 batches/cpusec, 83.2 batches/wallsec +GRPC/Unary/Async 400000 spans, CPU time 11.9 sec, wall time 5.6 sec, 67.0 batches/cpusec, 141.8 batches/wallsec +GRPC/OpenCensus 400000 spans, CPU time 23.9 sec, wall time 14.1 sec, 33.5 batches/cpusec, 56.8 batches/wallsec +GRPC/OpenCensusWithAck 400000 spans, CPU time 22.0 sec, wall time 21.1 sec, 36.4 batches/cpusec, 38.0 batches/wallsec +GRPC/Stream/NoLB 400000 spans, CPU time 10.7 sec, wall time 9.8 sec, 74.9 batches/cpusec, 81.8 batches/wallsec +GRPC/Stream/LBAlways/Sync 400000 spans, CPU time 11.5 sec, wall time 10.2 sec, 69.9 batches/cpusec, 78.2 batches/wallsec +GRPC/Stream/LBTimed/Sync 400000 spans, CPU time 11.1 sec, wall time 10.2 sec, 71.9 batches/cpusec, 78.4 batches/wallsec +GRPC/Stream/LBSrv/Async 400000 spans, CPU time 11.3 sec, wall time 7.0 sec, 70.5 batches/cpusec, 113.6 batches/wallsec +WebSocket/Stream/Sync 400000 spans, CPU time 10.3 sec, wall time 10.1 sec, 78.0 batches/cpusec, 79.4 batches/wallsec +WebSocket/Stream/Async 400000 spans, CPU time 10.5 sec, wall time 7.2 sec, 76.2 batches/cpusec, 111.2 batches/wallsec +WebSocket/Stream/Async/zlib 400000 spans, CPU time 29.0 sec, wall time 22.1 sec, 27.6 batches/cpusec, 36.1 batches/wallsec + +2ms network roundtrip latency +800 large batches, 500 spans per batch, 10 attrs per span +GRPC/Stream/LBTimed/Async/1 400000 spans, CPU time 11.1 sec, wall time 7.0 sec, 71.9 batches/cpusec, 114.9 batches/wallsec +GRPC/Stream/LBTimed/Async/10 400000 spans, CPU time 11.4 sec, wall time 5.4 sec, 70.5 batches/cpusec, 148.0 batches/wallsec +GRPC/Unary 400000 spans, CPU time 11.5 sec, wall time 11.8 sec, 69.5 batches/cpusec, 68.1 batches/wallsec +GRPC/Unary/Async 400000 spans, CPU time 11.3 sec, wall time 5.3 sec, 70.5 batches/cpusec, 150.4 batches/wallsec +GRPC/OpenCensus 400000 spans, CPU time 23.1 sec, wall time 13.6 sec, 34.6 batches/cpusec, 58.7 batches/wallsec +GRPC/OpenCensusWithAck 400000 spans, CPU time 21.9 sec, wall time 22.6 sec, 36.6 batches/cpusec, 35.4 batches/wallsec +GRPC/Stream/NoLB 400000 spans, CPU time 11.1 sec, wall time 11.6 sec, 72.3 batches/cpusec, 69.2 batches/wallsec +GRPC/Stream/LBAlways/Sync 400000 spans, CPU time 11.5 sec, wall time 11.6 sec, 69.8 batches/cpusec, 68.9 batches/wallsec +GRPC/Stream/LBTimed/Sync 400000 spans, CPU time 11.3 sec, wall time 11.7 sec, 71.0 batches/cpusec, 68.2 batches/wallsec +GRPC/Stream/LBSrv/Async 400000 spans, CPU time 11.1 sec, wall time 6.9 sec, 72.0 batches/cpusec, 115.1 batches/wallsec +WebSocket/Stream/Sync 400000 spans, CPU time 10.8 sec, wall time 12.0 sec, 74.1 batches/cpusec, 66.5 batches/wallsec +WebSocket/Stream/Async 400000 spans, CPU time 10.6 sec, wall time 7.2 sec, 75.5 batches/cpusec, 111.8 batches/wallsec +WebSocket/Stream/Async/zlib 400000 spans, CPU time 28.6 sec, wall time 21.9 sec, 27.9 batches/cpusec, 36.6 batches/wallsec + +20ms network roundtrip latency +400 large batches, 500 spans per batch, 10 attrs per span +GRPC/Stream/LBTimed/Async/1 200000 spans, CPU time 6.2 sec, wall time 4.1 sec, 64.9 batches/cpusec, 96.7 batches/wallsec +GRPC/Stream/LBTimed/Async/10 200000 spans, CPU time 6.2 sec, wall time 3.0 sec, 64.0 batches/cpusec, 132.9 batches/wallsec +GRPC/Unary 200000 spans, CPU time 6.2 sec, wall time 13.5 sec, 64.3 batches/cpusec, 29.6 batches/wallsec +GRPC/Unary/Async 200000 spans, CPU time 5.9 sec, wall time 3.0 sec, 68.0 batches/cpusec, 132.9 batches/wallsec +GRPC/OpenCensus 200000 spans, CPU time 12.6 sec, wall time 7.5 sec, 31.8 batches/cpusec, 53.3 batches/wallsec +GRPC/OpenCensusWithAck 200000 spans, CPU time 12.0 sec, wall time 19.5 sec, 33.4 batches/cpusec, 20.5 batches/wallsec +GRPC/Stream/NoLB 200000 spans, CPU time 5.9 sec, wall time 13.3 sec, 68.3 batches/cpusec, 30.0 batches/wallsec +GRPC/Stream/LBAlways/Sync 200000 spans, CPU time 5.9 sec, wall time 13.3 sec, 68.0 batches/cpusec, 30.2 batches/wallsec +GRPC/Stream/LBTimed/Sync 200000 spans, CPU time 5.8 sec, wall time 13.3 sec, 69.3 batches/cpusec, 30.1 batches/wallsec +GRPC/Stream/LBSrv/Async 200000 spans, CPU time 5.5 sec, wall time 3.7 sec, 73.4 batches/cpusec, 107.3 batches/wallsec +WebSocket/Stream/Sync 200000 spans, CPU time 5.8 sec, wall time 14.6 sec, 69.4 batches/cpusec, 27.4 batches/wallsec +WebSocket/Stream/Async 200000 spans, CPU time 5.5 sec, wall time 3.9 sec, 72.3 batches/cpusec, 102.1 batches/wallsec +WebSocket/Stream/Async/zlib 200000 spans, CPU time 14.7 sec, wall time 11.2 sec, 27.3 batches/cpusec, 35.7 batches/wallsec + +200ms network roundtrip latency +40 large batches, 500 spans per batch, 10 attrs per span +GRPC/Stream/LBTimed/Async/1 20000 spans, CPU time 0.5 sec, wall time 3.1 sec, 74.1 batches/cpusec, 12.7 batches/wallsec +GRPC/Stream/LBTimed/Async/10 20000 spans, CPU time 0.7 sec, wall time 3.1 sec, 61.5 batches/cpusec, 12.8 batches/wallsec +GRPC/Unary 20000 spans, CPU time 0.6 sec, wall time 9.9 sec, 65.6 batches/cpusec, 4.0 batches/wallsec +GRPC/Unary/Async 20000 spans, CPU time 0.6 sec, wall time 3.6 sec, 65.6 batches/cpusec, 11.1 batches/wallsec +GRPC/OpenCensus 20000 spans, CPU time 1.1 sec, wall time 3.5 sec, 35.1 batches/cpusec, 11.3 batches/wallsec +GRPC/OpenCensusWithAck 20000 spans, CPU time 1.2 sec, wall time 10.2 sec, 32.8 batches/cpusec, 3.9 batches/wallsec +GRPC/Stream/NoLB 20000 spans, CPU time 0.6 sec, wall time 9.5 sec, 67.8 batches/cpusec, 4.2 batches/wallsec +GRPC/Stream/LBAlways/Sync 20000 spans, CPU time 0.6 sec, wall time 9.5 sec, 63.5 batches/cpusec, 4.2 batches/wallsec +GRPC/Stream/LBTimed/Sync 20000 spans, CPU time 0.6 sec, wall time 9.5 sec, 66.7 batches/cpusec, 4.2 batches/wallsec +GRPC/Stream/LBSrv/Async 20000 spans, CPU time 0.5 sec, wall time 3.3 sec, 74.1 batches/cpusec, 12.0 batches/wallsec +WebSocket/Stream/Sync 20000 spans, CPU time 0.6 sec, wall time 13.5 sec, 69.0 batches/cpusec, 3.0 batches/wallsec +WebSocket/Stream/Async 20000 spans, CPU time 0.5 sec, wall time 6.1 sec, 74.1 batches/cpusec, 6.5 batches/wallsec +WebSocket/Stream/Async/zlib 20000 spans, CPU time 1.5 sec, wall time 2.0 sec, 26.3 batches/cpusec, 19.8 batches/wallsec + + +400 large batches, 500 spans per batch, 10 attrs per span +200ms network roundtrip latency +GRPC/OpenCensus 200000 spans, CPU time 11.9 sec, wall time 10.1 sec, 33.6 batches/cpusec, 39.6 batches/wallsec +GRPC/Stream/LBTimed/Async/1 200000 spans, CPU time 5.3 sec, wall time 9.5 sec, 76.0 batches/cpusec, 41.9 batches/wallsec +GRPC/Stream/LBTimed/Async/10 200000 spans, CPU time 6.4 sec, wall time 8.9 sec, 62.3 batches/cpusec, 44.7 batches/wallsec +GRPC/Unary/Async 200000 spans, CPU time 5.8 sec, wall time 12.0 sec, 68.6 batches/cpusec, 33.3 batches/wallsec +WebSocket/Stream/Async 200000 spans, CPU time 5.3 sec, wall time 11.2 sec, 75.3 batches/cpusec, 35.7 batches/wallsec +WebSocket/Stream/Async/zlib 200000 spans, CPU time 15.1 sec, wall time 12.0 sec, 26.5 batches/cpusec, 33.4 batches/wallsec +==================================================================================== +``` + +## Glossary + +There are 2 parties involved in telemetry data exchange. In this document the party that is the source of telemetry data is called the `Client`, the party that is the destination of telemetry data is called the `Server`. + +![Client-Server](images/otlp-client-server.png) + +Examples of a Client are instrumented applications or sending side of telemetry collectors, examples of Servers are telemetry backends or receiving side of telemetry collectors (so a Collector is typically both a Client and a Server depending on which side you look from). + +Both the Client and the Server are also a `Node`. This term is used in the document when referring to either one. + +## Acknowledgements + +Special thanks to Owais Lone who helped to conduct experiments with Load Balancers, to Paulo Janotti, Bogdan Drutu and Yuri Shkuro for thoughtful discussions around the protocol. diff --git a/text/images/otlp-client-server.png b/text/images/otlp-client-server.png new file mode 100644 index 0000000000000000000000000000000000000000..664fdd1eadbc9fd3c87096eb8035cd9affb56249 GIT binary patch literal 10256 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 Kx`{aJy#EVnO~%mx literal 0 HcmV?d00001 diff --git a/text/images/otlp-concurrent.png b/text/images/otlp-concurrent.png new file mode 100644 index 0000000000000000000000000000000000000000..17d1ae18ec6e1a9c76bd07daffa5b37da8e15f9c GIT binary patch literal 9983 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 literal 0 HcmV?d00001 diff --git a/text/images/otlp-multi-destination.png b/text/images/otlp-multi-destination.png new file mode 100644 index 0000000000000000000000000000000000000000..743a9020bd9c38ab9baa80b72a6b7f2878dd3bb5 GIT binary patch literal 24900 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 b`e%p5nl8T<}yoZz}t+JG* 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�)=7u?R)o1%XULCn3ZXZM{42m zPb02fx^x!Gby<0N^?2_0YSZyjcP$<{*+D6XWtfiW-clNLg|z#&ZQI~tfjo>e#5)3| zW(dEbfOGOktNnvlvY}sEGL!fZo4zVBF*SYRfD#oIT?a0jjdJI`4f2RpF(>3#rWQ7I z0Od>_z_Ok0v zaI&OoIRWetN*$1>JfWv|+2+=@Ca3w`KV}UN^21#b4bo9rD5j?L#pK_)b2+?es2ob6 z18_YBahjFPEEji*7nPJ`pP8BY%~*nT7mb}KpJZZkWy#aS&GSR)8A!RnJ(SImK5z1* zLsB$ty}yu5rU4W% zi8VNubLQ`aWZPuz9xoPZts?)Qw==UnUXvy-o o?#j?(P$a5dC5RZ#{*`r2ZBcq@?#GV7RcizRXP|W#V|(`h0LhqB(EtDd literal 0 HcmV?d00001