chore: update Tonic and Prost dependencies (#364)

This branch updates the console crates' dependency on `tonic` to v0.8.0
and `prost` to 0.11.0.

In addition, I've added a [`cargo xtask`][xtask] command for manually
regenerating the generated protobuf bindings.

This is necessary as the current approach, regenerating the bindings in
an integration test, does not work when the protos fail to compile
(which they do after the Tonic update). Since running the crate's tests
requires compiling the crate, if the proto bindings don't compile, we
can't re-run the test.

[xtask]: https://github.com/matklad/cargo-xtask

.cargo/config

@@ -1,2 +1,5 @@
 [build]
-rustflags = ["--cfg", "tokio_unstable"]
+rustflags = ["--cfg", "tokio_unstable"]
+
+[alias]
+xtask = "run --manifest-path ./xtask/Cargo.toml --"

.github/workflows/ci.yaml

@@ -75,6 +75,11 @@ jobs:
           override: true
       - uses: Swatinem/rust-cache@v1
 
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v1
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Run cargo test (API)
         uses: actions-rs/cargo@v1
         with:

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "tokio-console",
     "console-subscriber",
-    "console-api"
+    "console-api",
+    "xtask"
 ]
 resolver = "2"

console-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "console-api"
-version = "0.3.0"
+version = "0.4.0"
 license = "MIT"
 edition = "2021"
 rust-version = "1.58.0"
@@ -29,19 +29,21 @@ keywords = [
 transport = ["tonic-build/transport", "tonic/transport"]
 
 [dependencies]
-tonic = { version = "0.7", default-features = false, features = [
+tonic = { version = "0.8", default-features = false, features = [
     "prost",
     "codegen",
     "transport",
 ] }
-prost = "0.10"
-prost-types = "0.10"
+prost = "0.11"
+prost-types = "0.11"
 tracing-core = "0.1.17"
 
 [dev-dependencies]
-tonic-build = { version = "0.7", default-features = false, features = [
+tonic-build = { version = "0.8", default-features = false, features = [
     "prost", "transport"
 ] }
+# explicit dep so we can get the version with fixed whitespace.
+prost-build = "0.11.1"
 
 [package.metadata.docs.rs]
 all-features = true

console-api/src/generated/rs.tokio.console.common.rs

@@ -165,6 +165,18 @@ pub mod metadata {
         /// Indicates metadata is associated with an event.
         Event = 1,
     }
+    impl Kind {
+        /// String value of the enum field names used in the ProtoBuf definition.
+        ///
+        /// The values are not transformed in any way and thus are considered stable
+        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+        pub fn as_str_name(&self) -> &'static str {
+            match self {
+                Kind::Span => "SPAN",
+                Kind::Event => "EVENT",
+            }
+        }
+    }
     /// Describes the level of verbosity of a span or event.
     ///
     /// Corresponds to `Level` in the `tracing` crate.
@@ -191,6 +203,21 @@ pub mod metadata {
         /// Designates very low priority, often extremely verbose, information.
         Trace = 4,
     }
+    impl Level {
+        /// String value of the enum field names used in the ProtoBuf definition.
+        ///
+        /// The values are not transformed in any way and thus are considered stable
+        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+        pub fn as_str_name(&self) -> &'static str {
+            match self {
+                Level::Error => "ERROR",
+                Level::Warn => "WARN",
+                Level::Info => "INFO",
+                Level::Debug => "DEBUG",
+                Level::Trace => "TRACE",
+            }
+        }
+    }
 }
 /// Contains stats about objects that can be polled. Currently these can be:
 /// - tasks that have been spawned

console-api/src/generated/rs.tokio.console.instrument.rs

@@ -30,7 +30,7 @@ pub struct ResumeRequest {
 /// - we can use one single timestamp for all the data
 /// - we can have all the new_metadata in one place
 /// - things such as async ops and resource ops do not make sense
-///   on their own as they have relations to tasks and resources
+///    on their own as they have relations to tasks and resources
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Update {
     /// The system time when this update was recorded.
@@ -64,6 +64,7 @@ pub struct ResumeResponse {
 pub mod instrument_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
     use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
     /// `InstrumentServer<T>` implements `Instrument` as a service.
     #[derive(Debug, Clone)]
     pub struct InstrumentClient<T> {
@@ -84,19 +85,24 @@ pub mod instrument_client {
     where
         T: tonic::client::GrpcService<tonic::body::BoxBody>,
         T::Error: Into<StdError>,
-        T::ResponseBody: Default + Body<Data = Bytes> + Send + 'static,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
         <T::ResponseBody as Body>::Error: Into<StdError> + Send,
     {
         pub fn new(inner: T) -> Self {
             let inner = tonic::client::Grpc::new(inner);
             Self { inner }
         }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
         pub fn with_interceptor<F>(
             inner: T,
             interceptor: F,
         ) -> InstrumentClient<InterceptedService<T, F>>
         where
             F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
             T: tonic::codegen::Service<
                 http::Request<tonic::body::BoxBody>,
                 Response = http::Response<
@@ -109,19 +115,19 @@ pub mod instrument_client {
         {
             InstrumentClient::new(InterceptedService::new(inner, interceptor))
         }
-        /// Compress requests with `gzip`.
+        /// Compress requests with the given encoding.
         ///
         /// This requires the server to support it otherwise it might respond with an
         /// error.
         #[must_use]
-        pub fn send_gzip(mut self) -> Self {
-            self.inner = self.inner.send_gzip();
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
             self
         }
-        /// Enable decompressing responses with `gzip`.
+        /// Enable decompressing responses.
         #[must_use]
-        pub fn accept_gzip(mut self) -> Self {
-            self.inner = self.inner.accept_gzip();
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
             self
         }
         /// Produces a stream of updates representing the behavior of the instrumented async runtime.
@@ -258,8 +264,8 @@ pub mod instrument_server {
     #[derive(Debug)]
     pub struct InstrumentServer<T: Instrument> {
         inner: _Inner<T>,
-        accept_compression_encodings: (),
-        send_compression_encodings: (),
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
     }
     struct _Inner<T>(Arc<T>);
     impl<T: Instrument> InstrumentServer<T> {
@@ -283,6 +289,18 @@ pub mod instrument_server {
         {
             InterceptedService::new(Self::new(inner), interceptor)
         }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
     }
     impl<T, B> tonic::codegen::Service<http::Request<B>> for InstrumentServer<T>
     where
@@ -491,7 +509,7 @@ pub mod instrument_server {
             write!(f, "{:?}", self.0)
         }
     }
-    impl<T: Instrument> tonic::transport::NamedService for InstrumentServer<T> {
+    impl<T: Instrument> tonic::server::NamedService for InstrumentServer<T> {
         const NAME: &'static str = "rs.tokio.console.instrument.Instrument";
     }
 }

console-api/src/generated/rs.tokio.console.resources.rs

@@ -80,6 +80,17 @@ pub mod resource {
             /// `TIMER` signals that this is a timer resource, e.g. waiting for a sleep to finish.
             Timer = 0,
         }
+        impl Known {
+            /// String value of the enum field names used in the ProtoBuf definition.
+            ///
+            /// The values are not transformed in any way and thus are considered stable
+            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+            pub fn as_str_name(&self) -> &'static str {
+                match self {
+                    Known::Timer => "TIMER",
+                }
+            }
+        }
         /// Every resource is either a known kind or an other (unknown) kind.
         #[derive(Clone, PartialEq, ::prost::Oneof)]
         pub enum Kind {

console-api/src/generated/rs.tokio.console.tasks.rs

@@ -47,7 +47,7 @@ pub struct TaskDetails {
     ///
     /// This is either:
     /// - the raw binary representation of a HdrHistogram.rs `Histogram`
-    ///   serialized to binary in the V2 format (legacy)
+    ///    serialized to binary in the V2 format (legacy)
     /// - a binary histogram plus details on outliers (current)
     #[prost(oneof="task_details::PollTimesHistogram", tags="3, 4")]
     pub poll_times_histogram: ::core::option::Option<task_details::PollTimesHistogram>,
@@ -58,7 +58,7 @@ pub mod task_details {
     ///
     /// This is either:
     /// - the raw binary representation of a HdrHistogram.rs `Histogram`
-    ///   serialized to binary in the V2 format (legacy)
+    ///    serialized to binary in the V2 format (legacy)
     /// - a binary histogram plus details on outliers (current)
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum PollTimesHistogram {
@@ -125,6 +125,18 @@ pub mod task {
         /// (such as `tokio::task::spawn_blocking`).
         Blocking = 1,
     }
+    impl Kind {
+        /// String value of the enum field names used in the ProtoBuf definition.
+        ///
+        /// The values are not transformed in any way and thus are considered stable
+        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+        pub fn as_str_name(&self) -> &'static str {
+            match self {
+                Kind::Spawn => "SPAWN",
+                Kind::Blocking => "BLOCKING",
+            }
+        }
+    }
 }
 /// Task performance statistics.
 #[derive(Clone, PartialEq, ::prost::Message)]