note: this commit will not compile, code changes are intentionally
elided from this commit.
this commit upgrades hyper, http, tonic, prost, related dependencies,
and their assorted cargo features.
see <https://github.com/linkerd/linkerd2/issues/8733>.
---
squash:
chore(deps): add hyper-util workspace dependency
chore(deps): add http-body-util workspace dependency
chore(deps): upgrade linkerd2-proxy-api
this commit represents main as of linkerd/linkerd2-proxy-api#421.
Signed-off-by: katelyn martin <kate@buoyant.io>
this commit makes some minor alterations to our error recovery body
middleware. see https://github.com/linkerd/linkerd2/issues/8733 for more
information.
this commit removes an `assert!` statement from the implementation of
`<Response<R, B> as Body>::poll_data()`. see the documentation of
`Body::poll_frame()`:
> Once the end of the stream is reached, implementations should
> continue to return [`Poll::Ready(None)`].
1090bfff26 (diff-33aabe8c2aaa7614022addf244245e09bbff576a67a9ae3c6938c8a868201d36R60-R61)
to do this, this commit introduces a distinct terminal state
`Inner::Rescued` to represent when the underlying `B`-typed body has
yielded an error and been rescued. once in this state the body will
yield no more data frames, instead yielding a collection of trailers
describing the mid-stream error that was encountered by the underlying
body.
the call to `R::rescue` is also moved down into the helper function fka
`grpc_trailers()`. this helps the function follow the grain of our
"state machine" a little more directly.
see #3615, #3614, and #3611 for pretext to this change.
Signed-off-by: katelyn martin <kate@buoyant.io>
`linkerd-app-core` includes an error recovery body middleware. this middleware will gracefully catch and report errors encountered when polling an inner body, and via an `R`-typed recovery strategy provided by the caller, will attempt to map the error to a gRPC status code denoting an error.
before we upgrade to hyper 1.0 in service of https://github.com/linkerd/linkerd2/issues/8733, we add some test coverage to ensure that we preserve the behavior of this middleware.
see:
* linkerd/linkerd2#8733
* #3614.
for historical context on this tower layer, see:
* #222
* #1246
* #1282
---
* refactor(http/retry): outline `ForwardCompatibleBody<B>`
in #3559 (4b53081), we introduced a backported `Frame<T>` type, and a
`ForwardCompatibleBody<B>` type that allows us to interact with a
`http_body::Body` circa 0.4.6 in terms of frame-based interfaces that
match those of the 1.0 interface.
see linkerd/linkerd2#8733 for more information on upgrading hyper.
in #3559, we narrowly added this as an internal submodule of the
`linkerd-http-retry` library. these facilities however, would have
utility in other places such as `linkerd-app-core`.
this commit pulls these compatibility shims out into a
`linkerd-http-body-compat` library so that they can be imported and
reused elsewhere.
Signed-off-by: katelyn martin <kate@buoyant.io>
* nit(http/body-compat): tidy `combinators` imports
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(app/core): hoist `errors::code_header` helper
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(app/core): `l5d-*` constants are headers
these are header values. `http::HeaderName` has a const fn constructor,
so let's use that.
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(app/core): grpc constants are headers
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(app/core): hoist `l5d-` and `grpc-` constants
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(app/core): outline `ResponseBody` middleware
we'll add a few tests for this middleware shortly.
this commit moves this middleware out into its own submodule.
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(app/core): encapsulate `ResponseBody` enum
for other body middleware, we hide inner enum variants and their
constituent members by using the "inner" pattern.
this commit tweaks `ResponseBody` to follow suit, such that it now holds
an `Inner`, but does not expose its passthrough and rescue variants to
callers.
Signed-off-by: katelyn martin <kate@buoyant.io>
* docs(app/core): document `ResponseBody<R, B>`
this adds a small documentation comment describing what this type does.
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(app/core): a unit test suite for rescue body
this commit introduces a test suite for our error recovery middleware.
this body middleware provides a mechanism to "rescue" errors, gracefully
mapping an error encountered when polling a gRPC body into e.g. trailers
with a gRPC status code.
before we upgrade this middleware in service of linkerd/linkerd2#8733,
we add some test coverage to ensure that we preserve this middleware.
Signed-off-by: katelyn martin <kate@buoyant.io>
---------
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(http/retry): outline `ForwardCompatibleBody<B>`
in #3559 (4b53081), we introduced a backported `Frame<T>` type, and a
`ForwardCompatibleBody<B>` type that allows us to interact with a
`http_body::Body` circa 0.4.6 in terms of frame-based interfaces that
match those of the 1.0 interface.
see linkerd/linkerd2#8733 for more information on upgrading hyper.
in #3559, we narrowly added this as an internal submodule of the
`linkerd-http-retry` library. these facilities however, would have
utility in other places such as `linkerd-app-core`.
this commit pulls these compatibility shims out into a
`linkerd-http-body-compat` library so that they can be imported and
reused elsewhere.
Signed-off-by: katelyn martin <kate@buoyant.io>
* nit(http/body-compat): tidy `combinators` imports
Signed-off-by: katelyn martin <kate@buoyant.io>
---------
Signed-off-by: katelyn martin <kate@buoyant.io>
`MockBody` is a type that we use to implement tests for our
`peek_trailers::PeekTrailersBody<B>` body middleware. this is a useful
tool for mocking the polling outcomes of the inner body we wrap, which
would be useful for testing other `http_body::Body` middleware.
this commit moves `MockBody` out of `linkerd-http-retry`, and into a new
`linkerd-mock-http-body` crate. this is added as a test dependency for
the retry crate, and can now be used (rather than vendored) by other
bodies.
Signed-off-by: katelyn martin <kate@buoyant.io>
The 'hostname' label value is derived from the request URI and can be influenced
by applications. If a client uses a high cardinality of hostname values, this
leads to the proxy exporting many metrics and ultimately exhausting resources.
This change disables the 'hostname' label by default. A new field is outed to
the HTTP and TLS route parameters, `export_hostname_labels`, which can be used
to enable the 'hostname' label; however, this type is not yet configurable.
Changes are required to the proxy API and, ultimately, the policy controller, to
make this field configurable.
When the hostname is not exported, an empty label value is used.
BREAKING: The 'hostname' label is now disabled by default.
A previous change enabling OpenTelmetry forgot to include attributes from the span itself, in addition to the request level spans as we do in the old OpenCensus exporter. This adds those attributes back in.
Signed-off-by: Scott Fleener <scott@buoyant.io>
The outbound HTTP route labels use multiple ExtractParam implementations to
convert a matched route target to set of labels (using an HTTP request).
This change removes the RouteLabelExtract type, in favor of implementing label
extraction on the route target type directly.
pr #3559 (dd4fbcdb) refactored our trailer peeking body middleware to
model its buffering in terms of the `Frame<T>` type used in
`http-body`'s 1.0 release.
this branch performs a similar change for the other piece of body
middleware that super linkerd's retry facilities: `ReplayBody<B>`. the
inner body `B` is now wrapped in the `ForwardCompatibleBody<B>` adapter,
and we now poll it in terms of frames.
NB: polling the underlying in terms of frames has a subtle knock-on
effect regarding when we observe the trailers, in the liminal period
between this refactor and the subsequent upgrade to hyper 1.0, whilst we
must still implement the existing 0.4 interface for `Body` that includes
`poll_trailers()`.
see the comment above `replay_trailers` for more on this, describing why
we now initialize this to `true`. relatedly, this is why we no longer
delegate down to `B::poll_trailers` ourselves. it will have already been
called by our adapter.
`ReplayBody::is_end_stream()` now behaves identically when initially
polling a body compared to subsequent replays. this is fine, as
`is_end_stream()` is a hint that facilitates optimizations
(https://github.com/hyperium/http-body/pull/143). we do still report the end properly, we just
won't be quite as prescient on the initial playthrough.
in the same manner as the existing `frame()` method mimics
`http_body_util::BodyExt::frame()`, this branch introduces
a new `ForwardCompatibleBody::poll_frame()` method.
this allows us to poll the compatibility layer for a `Frame<T>`.
see:
- https://github.com/linkerd/linkerd2/issues/8733.
- https://github.com/linkerd/linkerd2-proxy/pull/3559
---
* nit(http/retry): install tracing subscriber in tests
some tests do not set up a tracing subscriber, because they do not use
the shared `Test::new()` helper function used elsewhere in this test
suite.
to provide a trace of the test's execution in the event of a failure,
initialize a tracing subscriber in some additional unit tests.
Signed-off-by: katelyn martin <kate@buoyant.io>
* feat(http/retry): `ForwardCompatibleBody<B>` exposes hints
this commit removes the `cfg(test)` gate on the method exposing
`B::is_end_stream()`, and introduces another method also exposing the
`size_hint()` method.
we will want these in order to implement these methods for
`ReplayBody<B>`.
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(http/retry): `ForwardCompatibleBody::poll_frame()`
in the same manner as the existing `frame()` method mimics
`http_body_util::BodyExt::frame()`, this commit introduces
a new `ForwardCompatibleBody::poll_frame()` method.
this allows us to poll the compatibility layer for a `Frame<T>`.
Signed-off-by: katelyn martin <kate@buoyant.io>
* feat(http/retry): `ReplayBody<B>` polls for frames
pr #3559 (dd4fbcd) refactored our trailer peeking body middleware to
model its buffering in terms of the `Frame<T>` type used in
`http-body`'s 1.0 release.
this commit performs a similar change for the other piece of body
middleware that super linkerd's retry facilities: `ReplayBody<B>`. the
inner body `B` is now wrapped in the `ForwardCompatibleBody<B>` adapter,
and we now poll it in terms of frames.
NB: polling the underlying in terms of frames has a subtle knock-on
effect regarding when we observe the trailers, in the liminal period
between this refactor and the subsequent upgrade to hyper 1.0, whilst we
must still implement the existing 0.4 interface for `Body` that includes
`poll_trailers()`.
see the comment above `replay_trailers` for more on this, describing why
we now initialize this to `true`. relatedly, this is why we now longer
delegate down to `B::poll_trailers` ourselves. it will have already been
called by our adapter.
`ReplayBody::is_end_stream()` now behaves identically when initially
polling a body compared to subsequent replays. this is fine, as
`is_end_stream()` is a hint that facilitates optimizations
(hyperium/http-body#143). we do still report the end properly, we just
won't be quite as prescient on the initial playthrough.
see:
- https://github.com/linkerd/linkerd2/issues/8733.
- https://github.com/linkerd/linkerd2-proxy/pull/3559
Signed-off-by: katelyn martin <kate@buoyant.io>
* feat(http/retry): `is_end_stream()` traces
this commit introduces some trace-level diagnostics tracking how the
replay body has determined whether or not it has reached the end of the
stream.
Signed-off-by: katelyn martin <kate@buoyant.io>
* nit(http/retry): capitalize trace event messages
Signed-off-by: katelyn martin <kate@buoyant.io>
---------
Signed-off-by: katelyn martin <kate@buoyant.io>
the `ReplayBody<B>` middleware makes use of a `BufList` type to hold a
reference to bytes yielded by the inner body `B`. a `Data` enum is
composed on top to this, to allow bodies to either return (a) a replay
of a previous body, or (b) the iniial bytes yielded by the original
body.
this branch also takes the step of moving some code out of the
`ReplayBody::poll_data(..)` trait method along with inlining
`BufList::push_chunk(..)` , a small helper function that is only used
once.
this is intended to consolidate code related to buffering data yielded
by the underlying `B`-typed body, and extricate logic concerning the
bounding of this buffer from the now defunct `Body::poll_data()` trait
method.
see https://github.com/linkerd/linkerd2/issues/8733 for more information
about upgrading the proxy to hyper 1.0.
this will help make subsequent changes to the model of `ReplayBody<B>`
its corresponding `Body` implementation more reviewable, by proactively
reorganizing things in advance.
---
* refactor(http/retry): outline replay buffer
the replay body uses this `BufList` type to hold a reference to bytes
yielded by the inner body `B`.
the `Data` enum is composed on top to this, to allow bodies to either
return a replay of a previous body, or the iniial bytes yielded by the
original body.
this is all relatively self-contained, so we can move this into a small
submodule.
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(http/retry): outline replay body buffering
this commit moves some code out of the `ReplayBody::poll_data(..)` trait
method.
this bit of code is where we take a chunk of a data yielded by the inner
body, and push it into our replay buffer. if the capacity is exceeded,
we flush the buffer. in either case, the code copies the chunk into a
cheaply cloneable, contiguous `Bytes`.
this is all related to the buffer, so we move it there.
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(http/retry): inline `BufList::push_chunk`
`push_chunk` is a small helper function that is only used once. now that
we have moved our buffering code alongside this type, it's more
straightforward to inline this function.
Signed-off-by: katelyn martin <kate@buoyant.io>
* refactor(http/retry): rename `BufList` to `Replay`
this structure is responsible for acting as the `bytes::Buf` buffer for
the replay of the initial body.
this commit renames this to articulate that relationship more directly.
Signed-off-by: katelyn martin <kate@buoyant.io>
* docs(http/retry): polish `Replay` documentation
Signed-off-by: katelyn martin <kate@buoyant.io>
---------
Signed-off-by: katelyn martin <kate@buoyant.io>
this commit makes some small, admittedly subjective tweaks to
`ReplayBody::poll_trailers(..)`.
we can make use of the `map_ok` and `map_err` methods that exist to map
`Poll::Ready<Result<T, E>>`'s inner `T` to some `U` (in our case, to
record the trailers for later replay), and to map the error type into a
boxed `Error`.
this is a minor tweak, front-running other work to port the
`ReplayBody<B>` to http-body 1.0. see
https://github.com/linkerd/linkerd2/issues/8733.
Signed-off-by: katelyn martin <kate@buoyant.io>
`ReplayBody<B>` is slightly inconsistent about how it represents the
exhaustion of the inner `B`-typed body.
first, in `poll_data()` we poll the inner body, and note that we
consider a `None` value for `BodyState::rest` to mean that there is no
more work to do.
```rust
// Poll the inner body for more data. If the body has ended, remember
// that so that future clones will not try polling it again (as
// described above).
let mut data = {
// Get access to the initial body. If we don't have access to the
// inner body, there's no more work to do.
let rest = match state.rest.as_mut() {
Some(rest) => rest,
None => return Poll::Ready(None),
};
// ...
};
```
then, in `Body::is_end_stream()`, we write the following to check that
the stream is done:
```rust
let is_inner_eos = self
.state
.as_ref()
.and_then(|state| state.rest.as_ref().map(Body::is_end_stream))
.unwrap_or(false);
```
note in particular the call to `Option::and_then(..)`.
this means that, should the inner body be `None`, we will begin
reporting the stream as **not** finished. this is backwards!
this commit makes a change to the definition of `BodyState<B>`. it no
longer treats its inner body as optional. we never drop the inner body
`B`, to facilitate gracefully replaying bodies that were interrupted
when initially being polled.
a bare `B` means that various bits of control are now simpler, without
having to account for the `Option<T>` state.
Signed-off-by: katelyn martin <kate@buoyant.io>
This environment variable is definted by the OpenTelemetry conventions as a way of specifying additional resource attributes to be included in traces: https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#general-sdk-configuration
Note that this is parallel to LINKERD2_PROXY_TRACE_EXTRA_ATTRIBUTES, which is meant for common attributes that should always be provided by the proxy (pod UID, contianer name, etc.). We do not expect users to override that one, as OTEL_RESOURCE_ATTRIBUTES is the conventional way of specifying custom attributes.
Signed-off-by: Scott Fleener <scott@buoyant.io>
see https://github.com/linkerd/linkerd2/issues/8733.
we are currently in the process of upgrading our hyper, http, and http-body dependencies to their 1.0 major releases.
this branch introduces additional test coverage, and further refines existing test coverage, concerning how a `ReplayBody<B>` behaves when it reaches the "end of stream" of its internal `B`-typed body.
additional assertions are added to show that bodies with trailers may be replayed an arbitrary number of times, and that capacity errors occur precisely at their expected boundary. additional assertions are added to confirm that `ReplayBody::is_capped()` reports these conditions properly.
this branch also notably outlines the unit test suite into a separate file, due to its size. as a result, reviewers are encouraged to walk through this branch on a commit-by-commit basis when reading these changes.
i noticed some relatively minor issues with `is_end_stream()` and `size_hint()` while i was reviewing this middleware, in preparation to port it to http-body 1.0. i have left `TODO` comments noting where today's behavior is slightly askew, but _intentionally avoided_ fixing them here. my goal on that front is to highlight those wrinkles so that later fixes to these edges are more easily reviewable.
---
* refactor(http/retry): outline `ReplayBody<B>` unit tests
there are more than 500 lines of unit tests. let's move them into a
submodule, for convenience.
Signed-off-by: katelyn martin <kate@buoyant.io>
* nit(http/retry): reorganize replay tests
this is a small cosmetic change reording some test helpers.
there is a common convention of affixing a banner comment above groups
of `impl T {}` blocks, which is useful when top-level blocks are folded
in an editor.
similarly, there is a convention of defining structures at the top of a
file.
this commit reorganizes the replay body tests to follow each of these
conventions.
Signed-off-by: katelyn martin <kate@buoyant.io>
* nit(http/retry): test replays trailers twice
just to be extra sure!
Signed-off-by: katelyn martin <kate@buoyant.io>
* nit(http/retry): rename `trailers_only()` test
this is part of a family of other tests called `replays_one_chunk()`,
`replays_several_chunks()`, and `replays_trailers()`. let's name this
something that lines up with this convention.
Signed-off-by: katelyn martin <kate@buoyant.io>
* feat(http/retry): add a `TestBody` type
we have a unit test, called `eos_only_when_fully_replayed` that confirms
`Body::end_of_stream()` reports the stream ending properly.
soon, we aim to introduce additional test coverage that exercises this
when a body has trailers, as well. this will be useful for assurance
related to upgrading to http-body v1.x. see linkerd/linkerd2#8733 for
more information.
unfortunately, hyper 0.14's channel-backed body does not report itself
as having reached the end of the stream. this is an unfortunate quality
that prevents us from using `Test::new()`.
this commit adds a `TestBody` type that we can use in place of
`BoxBody::from_static(..)`, which boxes a static string, but does not
send trailers.
Signed-off-by: katelyn martin <kate@buoyant.io>
* feat(http/retry): add `is_end_stream()` coverage for trailers
this commit introduces additional test coverage that exercises
`is_end_stream()` when a replay body is wrapping a body with trailers.
this will be useful for assurance related to upgrading to http-body
v1.x. see linkerd/linkerd2#8733 for more information.
Signed-off-by: katelyn martin <kate@buoyant.io>
* feat(http/retry): add `is_capped()` test coverage
Signed-off-by: katelyn martin <kate@buoyant.io>
* feat(http/retry): further refine capacity test coverage
we want to show that exceeding the capacity is the point at which
replays will fail.
this commit defines some constants to further communicate and encode
this relationship between the bytes sent, and the capacity of the replay
body.
further, it shortens the second frame sent so that we ensure precisely
when a body becomes capped.
Signed-off-by: katelyn martin <kate@buoyant.io>
* feat(http/retry): add `size_hint()` test coverage
Signed-off-by: katelyn martin <kate@buoyant.io>
* chore(http/retry): add todo comments concerning eos
for now, a replaying body that will not yield trailers must be polled to
the `None` before reporting itself as reaching the end of the stream.
this isn't hugely important, but does affect some test control flow.
leave two todo comments so that if/when upgrading to hyper 1.0, it is
clear that these are not load-bearing or otherwise expected behavior,
should this behavior be rectified.
Signed-off-by: katelyn martin <kate@buoyant.io>
---------
Signed-off-by: katelyn martin <kate@buoyant.io>
a `ReplayBody<B>` demands a particular contract of its users: one must not poll two bodies in parallel. this is currently mentioned as an implicit assumption on an internal helper function, `acquire_state<'a>`, here:
https://github.com/linkerd/linkerd2-proxy/blob/main/linkerd/http/retry/src/replay.rs#L127-L131
```rust
/// # Panics
///
/// This panics if another clone has currently acquired the state, based on
/// the assumption that a retry body will not be polled until the previous
/// request has been dropped.
fn acquire_state<'a>(
state: &'a mut Option<BodyState<B>>,
shared: &Mutex<Option<BodyState<B>>>,
) -> &'a mut BodyState<B> {
state.get_or_insert_with(|| shared.lock().take().expect("missing body state"))
}
```
this commit echoes this sentiment on the relevant public-facing parts of this middleware: its `Body` trait methods.
Signed-off-by: katelyn martin <kate@buoyant.io>
This allows us to include arbitrary values from the k8s downward API beyond just the pod labels that are included in the trace attributes file.
See https://github.com/linkerd/linkerd2/pull/13544 for the corresponding control plane change.
Signed-off-by: Scott Fleener <scott@buoyant.io>
pr's #3564 and #3567, 1eb822f2 and 32042783 respectively, replaced uses
of defunct `http_body::Body` trait methods — namely, `data()` and
`trailers()`.
this commit updates two remaining uses of `data()` that were missed
in this initial pass.
see linkerd/linkerd2#8733 for more information.
Signed-off-by: katelyn martin <kate@buoyant.io>
katelyn martin
dependabot[bot]
Oliver Gould
Scott Fleener