feat: runtime agnostic

Author: Miaxos

Cargo.toml

@@ -14,6 +14,8 @@ edition = "2018"
 [features]
 default = []
 compression = ["libflate"]
+tokio-comp = ["tokio"]
+async-std-comp = ["async-std"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
@@ -23,7 +25,6 @@ tracing = "0.1.*"
 tracing-futures = { version = "0.2.5", default-features = false, features = ["tokio", "futures-03", "std"] }
 futures = "0.3.*"                 # An implementation of futures and streams featuring zero allocations, composability, and itera…
 chrono = "0.4.15"
-tokio = { version = "1", features = ["full"] }
 reqwest = { version = "0.11.*", features = ["json"] }
 async-trait = "0.1.*" 
 serde_json = "1.0.*"                     # A JSON serialization file format
@@ -33,3 +34,5 @@ uuid = { version = "0.8.*", features = ["v4"] }                  # A library to
 
 # Non-feature optional dependencies
 libflate = { version = "1", optional = true }
+tokio = { version = "1", features = ["full"], optional = true }
+async-std = { version = "1.9", optional = true }

README.md

@@ -49,6 +49,8 @@ _Tested at Rust version: `rustc 1.53.0 (53cb7b09b 2021-06-17)`_
 This crate offers the following features, all of which are not activated by default:
 
 - `compression`: Enable the GZIP Compression when sending traces.
+- `tokio-comp`: Enable the Tokio compatibility  when you have a tokio-runtime
+- `async-std-comp`: Enable the async-std compatibility  when you have a async-std-runtime
 
 ## Examples
 

src/lib.rs

@@ -29,6 +29,7 @@ mod compression;
 mod packages;
 mod proto;
 pub mod register;
+mod runtime;
 
 #[macro_use]
 extern crate tracing;
@@ -53,9 +54,8 @@ use proto::{
     Report, ReportHeader, Trace, Trace_Details, Trace_Error, Trace_HTTP, Trace_HTTP_Method,
     Trace_Location, Trace_Node, Trace_Node_oneof_id, TracesAndStats,
 };
+use runtime::{channel, Runtime, RwLock, Sender};
 use std::convert::TryInto;
-use tokio::sync::mpsc::{channel, Sender};
-use tokio::sync::RwLock;
 
 /// Apollo Tracing Extension to send traces to Apollo Studio
 /// The extension to include to your `async_graphql` instance to connect with Apollo Studio.
@@ -199,11 +199,16 @@ impl ApolloTracing {
 
         let header_tokio = Arc::clone(&header);
 
-        tokio::spawn(async move {
+        Runtime::locate().spawn(async move {
             let mut hashmap: HashMap<String, TracesAndStats> =
                 HashMap::with_capacity(batch_target + 1);
             let mut count = 0;
-            while let Some((name, trace)) = receiver.recv().await {
+            while let Some((name, trace)) = match Runtime::locate() {
+                #[cfg(feature = "tokio-comp")]
+                Runtime::Tokio => receiver.recv().await,
+                #[cfg(feature = "async-std-comp")]
+                Runtime::AsyncStd => receiver.recv().await.ok(),
+            } {
                 trace!(target: TARGET_LOG, message = "Trace registered", trace = ?trace, name = ?name);
 
                 // We bufferize traces and create a Full Report every X
@@ -450,7 +455,7 @@ impl Extension for ApolloTracingExtension {
         let sender = self.sender.clone();
 
         let operation_name = self.operation_name.read().await.clone();
-        tokio::spawn(async move {
+        Runtime::locate().spawn(async move {
             if let Err(e) = sender.send((operation_name, trace)).await {
                 error!(error = ?e);
             }

src/runtime.rs

@@ -0,0 +1,57 @@
+use futures::Future;
+
+#[cfg(feature = "async-std-comp")]
+pub use async_std::channel::{bounded as channel, Receiver, Sender};
+#[cfg(feature = "async-std-comp")]
+pub use async_std::sync::RwLock;
+#[cfg(feature = "tokio-comp")]
+pub use tokio::sync::mpsc::{channel, Receiver, Sender};
+#[cfg(feature = "tokio-comp")]
+pub use tokio::sync::RwLock;
+
+// From https://github.com/mitsuhiko/redis-rs/blob/99a97e8876c99df5a0cf5536fbff21b5d9cae14c/src/aio.rs
+#[derive(Clone, Debug)]
+pub(crate) enum Runtime {
+    #[cfg(feature = "tokio-comp")]
+    Tokio,
+    #[cfg(feature = "async-std-comp")]
+    AsyncStd,
+}
+
+impl Runtime {
+    pub fn locate() -> Self {
+        #[cfg(all(feature = "tokio-comp", not(feature = "async-std-comp")))]
+        {
+            Runtime::Tokio
+        }
+
+        #[cfg(all(not(feature = "tokio-comp"), feature = "async-std-comp"))]
+        {
+            Runtime::AsyncStd
+        }
+
+        #[cfg(all(feature = "tokio-comp", feature = "async-std-comp"))]
+        {
+            if ::tokio::runtime::Handle::try_current().is_ok() {
+                Runtime::Tokio
+            } else {
+                Runtime::AsyncStd
+            }
+        }
+
+        #[cfg(all(not(feature = "tokio-comp"), not(feature = "async-std-comp")))]
+        {
+            compile_error!("tokio-comp or async-std-comp features required")
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn spawn(&self, f: impl Future<Output = ()> + Send + 'static) {
+        match self {
+            #[cfg(feature = "tokio-comp")]
+            Runtime::Tokio => tokio::spawn(f),
+            #[cfg(feature = "async-std-comp")]
+            Runtime::AsyncStd => async_std::task::spawn(f),
+        };
+    }
+}