Context: Rc -> Arc (#127)

Author: bbigras

src/api/context/mod.rs

@@ -68,7 +68,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt;
 use std::hash::{BuildHasherDefault, Hasher};
-use std::rc::Rc;
+use std::sync::Arc;
 
 pub mod propagation;
 
@@ -80,7 +80,7 @@ thread_local! {
 /// An execution-scoped collection of values.
 #[derive(Clone, Default)]
 pub struct Context {
-    entries: HashMap<TypeId, Rc<dyn Any>, BuildHasherDefault<IdHasher>>,
+    entries: HashMap<TypeId, Arc<dyn Any + Sync + Send>, BuildHasherDefault<IdHasher>>,
 }
 
 impl Context {
@@ -141,11 +141,11 @@ impl Context {
     /// assert_eq!(all_current_and_b.get::<ValueA>(), Some(&ValueA("a")));
     /// assert_eq!(all_current_and_b.get::<ValueB>(), Some(&ValueB(42)));
     /// ```
-    pub fn current_with_value<T: 'static>(value: T) -> Self {
+    pub fn current_with_value<T: 'static + Send + Sync>(value: T) -> Self {
         let mut new_context = Context::current();
         new_context
             .entries
-            .insert(TypeId::of::<T>(), Rc::new(value));
+            .insert(TypeId::of::<T>(), Arc::new(value));
 
         new_context
     }
@@ -204,11 +204,11 @@ impl Context {
     /// assert_eq!(cx_with_a_and_b.get::<ValueA>(), Some(&ValueA("a")));
     /// assert_eq!(cx_with_a_and_b.get::<ValueB>(), Some(&ValueB(42)));
     /// ```
-    pub fn with_value<T: 'static>(&self, value: T) -> Self {
+    pub fn with_value<T: 'static + Send + Sync>(&self, value: T) -> Self {
         let mut new_context = self.clone();
         new_context
             .entries
-            .insert(TypeId::of::<T>(), Rc::new(value));
+            .insert(TypeId::of::<T>(), Arc::new(value));
 
         new_context
     }

src/api/trace/context.rs

@@ -5,20 +5,20 @@ lazy_static::lazy_static! {
     static ref NOOP_SPAN: api::NoopSpan = api::NoopSpan::new();
 }
 
-struct Span(Box<dyn api::Span>);
+struct Span(Box<dyn api::Span + Send + Sync>);
 struct RemoteSpanContext(api::SpanContext);
 
 /// Methods for storing and retrieving trace data in a context.
 pub trait TraceContextExt {
     /// Returns a clone of the current context with the included span.
     ///
     /// This is useful for building tracers.
-    fn current_with_span<T: api::Span>(span: T) -> Self;
+    fn current_with_span<T: api::Span + Send + Sync>(span: T) -> Self;
 
     /// Returns a clone of this context with the included span.
     ///
     /// This is useful for building tracers.
-    fn with_span<T: api::Span>(&self, span: T) -> Self;
+    fn with_span<T: api::Span + Send + Sync>(&self, span: T) -> Self;
 
     /// Returns a reference to this context's span, or the default no-op span if
     /// none has been set.
@@ -51,11 +51,11 @@ pub trait TraceContextExt {
 }
 
 impl TraceContextExt for api::Context {
-    fn current_with_span<T: api::Span>(span: T) -> Self {
+    fn current_with_span<T: api::Span + Send + Sync>(span: T) -> Self {
         api::Context::current_with_value(Span(Box::new(span)))
     }
 
-    fn with_span<T: api::Span>(&self, span: T) -> Self {
+    fn with_span<T: api::Span + Send + Sync>(&self, span: T) -> Self {
         self.with_value(Span(Box::new(span)))
     }
 

src/api/trace/span.rs

@@ -22,7 +22,7 @@ use std::fmt;
 use std::time::SystemTime;
 
 /// Interface for a single operation within a trace.
-pub trait Span: fmt::Debug + 'static {
+pub trait Span: fmt::Debug + 'static + Send + Sync {
     /// An API to record events in the context of a given `Span`.
     ///
     /// Events have a time associated with the moment when they are