futures: add support for std::futures::Future (#40)

This PR adds a `std::future::Future` implementation to `Instrumented<T>`

* futures: add support for std::futures::Future and futures 0.3

* futures: support std::futures::Future with !Unpin futures

- Thank you Eliza Weisman (hawkw) for the solution using the pin-utils crate
- Added feature gates for the futures 0.1, tokio, and std::future implementations

* futures: fix formatting

* futures: rustfmt

* futures: use tokio-test for testing std::future::Future unit tests

* futures: rustfmt

* futures: remove futures_api conditional include

* futures: add testing of all features under nightly

* futures: separate std-future tests into submodule that is only run on the nightly toolchain

* futures: move futures-01 tests to submodule

* futures: fix travis build

* future: remove extraneous part of function names

- test_std_future is part of the namespace so having std_future as part of the test function name is not needed

Author: mbilker

.travis.yml

@@ -28,3 +28,6 @@ jobs:
   - script: cargo test --features=doctest-readme --all
     name: "doctest readme"
     rust: nightly
+  - script: (cd tracing-futures/test_std_future && cargo test)
+    name: "futures nightly"
+    rust: nightly

tracing-futures/Cargo.toml

@@ -5,10 +5,13 @@ authors = ["Eliza Weisman <[email protected]>"]
 edition = "2018"
 
 [features]
-default = ["tokio"]
+default = ["futures-01", "tokio"]
+futures-01 = ["futures"]
+std-future = ["pin-utils"]
 
 [dependencies]
-futures = "0.1"
+futures = { version = "0.1", optional = true }
+pin-utils = { version = "0.1.0-alpha.4", optional = true }
 tracing = "0.1"
 tokio = { version = "0.1", optional = true }
 tokio-executor = { version = "0.1", optional = true }

tracing-futures/src/executor.rs

@@ -1,15 +1,14 @@
 use crate::{Instrument, Instrumented, WithDispatch};
+#[cfg(feature = "futures-01")]
 use futures::{
     future::{ExecuteError, Executor},
     Future,
 };
+#[cfg(feature = "futures-01")]
+use tokio::executor::{Executor as TokioExecutor, SpawnError};
+use tokio::runtime::{current_thread, Runtime, TaskExecutor};
 
-#[cfg(feature = "tokio")]
-use tokio::{
-    executor::{Executor as TokioExecutor, SpawnError},
-    runtime::{current_thread, Runtime, TaskExecutor},
-};
-
+#[cfg(feature = "futures-01")]
 macro_rules! deinstrument_err {
     ($e:expr) => {
         $e.map_err(|e| {
@@ -20,6 +19,7 @@ macro_rules! deinstrument_err {
     };
 }
 
+#[cfg(feature = "futures-01")]
 impl<T, F> Executor<F> for Instrumented<T>
 where
     T: Executor<Instrumented<F>>,
@@ -31,7 +31,7 @@ where
     }
 }
 
-#[cfg(feature = "tokio")]
+#[cfg(all(feature = "futures-01", feature = "tokio"))]
 impl<T> TokioExecutor for Instrumented<T>
 where
     T: TokioExecutor,
@@ -56,6 +56,7 @@ impl Instrumented<Runtime> {
     ///
     /// This method simply wraps a call to `tokio::runtime::Runtime::spawn`,
     /// instrumenting the spawned future beforehand.
+    #[cfg(feature = "futures-01")]
     pub fn spawn<F>(&mut self, future: F) -> &mut Self
     where
         F: Future<Item = (), Error = ()> + Send + 'static,
@@ -80,6 +81,7 @@ impl Instrumented<Runtime> {
     ///
     /// This function panics if the executor is at capacity, if the provided
     /// future panics, or if called within an asynchronous execution context.
+    #[cfg(feature = "futures-01")]
     pub fn block_on<F, R, E>(&mut self, future: F) -> Result<R, E>
     where
         F: Send + 'static + Future<Item = R, Error = E>,
@@ -108,6 +110,7 @@ impl Instrumented<current_thread::Runtime> {
     ///
     /// This method simply wraps a call to `current_thread::Runtime::spawn`,
     /// instrumenting the spawned future beforehand.
+    #[cfg(feature = "futures-01")]
     pub fn spawn<F>(&mut self, future: F) -> &mut Self
     where
         F: Future<Item = (), Error = ()> + 'static,
@@ -141,6 +144,7 @@ impl Instrumented<current_thread::Runtime> {
     ///
     /// This function panics if the executor is at capacity, if the provided
     /// future panics, or if called within an asynchronous execution context.
+    #[cfg(feature = "futures-01")]
     pub fn block_on<F, R, E>(&mut self, future: F) -> Result<R, E>
     where
         F: 'static + Future<Item = R, Error = E>,
@@ -165,6 +169,7 @@ impl Instrumented<current_thread::Runtime> {
     }
 }
 
+#[cfg(feature = "futures-01")]
 impl<T, F> Executor<F> for WithDispatch<T>
 where
     T: Executor<WithDispatch<F>>,
@@ -176,7 +181,7 @@ where
     }
 }
 
-#[cfg(feature = "tokio")]
+#[cfg(all(feature = "futures-01", feature = "tokio"))]
 impl<T> TokioExecutor for WithDispatch<T>
 where
     T: TokioExecutor,
@@ -202,6 +207,7 @@ impl WithDispatch<Runtime> {
     ///
     /// This method simply wraps a call to `tokio::runtime::Runtime::spawn`,
     /// instrumenting the spawned future beforehand.
+    #[cfg(feature = "futures-01")]
     pub fn spawn<F>(&mut self, future: F) -> &mut Self
     where
         F: Future<Item = (), Error = ()> + Send + 'static,
@@ -227,6 +233,7 @@ impl WithDispatch<Runtime> {
     ///
     /// This function panics if the executor is at capacity, if the provided
     /// future panics, or if called within an asynchronous execution context.
+    #[cfg(feature = "futures-01")]
     pub fn block_on<F, R, E>(&mut self, future: F) -> Result<R, E>
     where
         F: Send + 'static + Future<Item = R, Error = E>,
@@ -257,6 +264,7 @@ impl WithDispatch<current_thread::Runtime> {
     ///
     /// This method simply wraps a call to `current_thread::Runtime::spawn`,
     /// instrumenting the spawned future beforehand.
+    #[cfg(feature = "futures-01")]
     pub fn spawn<F>(&mut self, future: F) -> &mut Self
     where
         F: Future<Item = (), Error = ()> + 'static,
@@ -290,6 +298,7 @@ impl WithDispatch<current_thread::Runtime> {
     ///
     /// This function panics if the executor is at capacity, if the provided
     /// future panics, or if called within an asynchronous execution context.
+    #[cfg(feature = "futures-01")]
     pub fn block_on<F, R, E>(&mut self, future: F) -> Result<R, E>
     where
         F: 'static + Future<Item = R, Error = E>,