diff --git a/opentelemetry-jaeger/src/exporter/collector.rs b/opentelemetry-jaeger/src/exporter/collector.rs
index e39fc63a31..1653ac23f9 100644
--- a/opentelemetry-jaeger/src/exporter/collector.rs
+++ b/opentelemetry-jaeger/src/exporter/collector.rs
@@ -33,14 +33,14 @@ mod collector_client {
 
     impl CollectorAsyncClientHttp {
         /// Create a new HTTP collector client
-        pub(crate) fn new(endpoint: Uri, client: Box<dyn HttpClient>) -> thrift::Result<Self> {
+        pub(crate) fn new(endpoint: Uri, client: Box<dyn HttpClient>) -> Self {
             let payload_size_estimate = AtomicUsize::new(512);
 
-            Ok(CollectorAsyncClientHttp {
+            CollectorAsyncClientHttp {
                 endpoint,
                 client,
                 payload_size_estimate,
-            })
+            }
         }
 
         /// Submit list of Jaeger batches
diff --git a/opentelemetry-jaeger/src/exporter/mod.rs b/opentelemetry-jaeger/src/exporter/mod.rs
index 1984857c7d..989f1621ba 100644
--- a/opentelemetry-jaeger/src/exporter/mod.rs
+++ b/opentelemetry-jaeger/src/exporter/mod.rs
@@ -390,8 +390,7 @@ impl PipelineBuilder {
                 Box::new(client)
             });
 
-            let collector = CollectorAsyncClientHttp::new(collector_endpoint, client)
-                .map_err::<Error, _>(Into::into)?;
+            let collector = CollectorAsyncClientHttp::new(collector_endpoint, client);
             Ok((self.process, uploader::BatchUploader::Collector(collector)))
         } else {
             let endpoint = self.agent_endpoint.as_slice();
@@ -568,7 +567,7 @@ fn convert_otel_span_into_jaeger_span(
             .duration_since(span.start_time)
             .unwrap_or_else(|_| Duration::from_secs(0))
             .as_micros() as i64,
-        tags: build_span_tags(
+        tags: Some(build_span_tags(
             span.attributes,
             if export_instrument_lib {
                 Some(span.instrumentation_lib)
@@ -578,7 +577,7 @@ fn convert_otel_span_into_jaeger_span(
             span.status_code,
             span.status_message,
             span.span_kind,
-        ),
+        )),
         logs: events_to_logs(span.message_events),
     }
 }
@@ -604,7 +603,7 @@ fn build_span_tags(
     status_code: StatusCode,
     status_message: String,
     kind: SpanKind,
-) -> Option<Vec<jaeger::Tag>> {
+) -> Vec<jaeger::Tag> {
     let mut user_overrides = UserOverrides::default();
     // TODO determine if namespacing is required to avoid collisions with set attributes
     let mut tags = attrs
@@ -658,7 +657,7 @@ fn build_span_tags(
         }
     }
 
-    Some(tags)
+    tags
 }
 
 const ERROR: &str = "error";
@@ -838,8 +837,7 @@ mod tests {
                 status_code,
                 error_msg,
                 SpanKind::Client,
-            )
-            .unwrap_or_default();
+            );
             if let Some(val) = status_tag_val {
                 assert_tag_contains(tags.clone(), OTEL_STATUS_CODE, val);
             } else {
diff --git a/opentelemetry/src/api/metrics/number.rs b/opentelemetry/src/api/metrics/number.rs
index 4f887f9bfa..26e10c1ab7 100644
--- a/opentelemetry/src/api/metrics/number.rs
+++ b/opentelemetry/src/api/metrics/number.rs
@@ -92,24 +92,36 @@ impl AtomicNumber {
     /// `inf` for `f64`.
     pub fn fetch_add(&self, number_kind: &NumberKind, val: &Number) {
         match number_kind {
-            NumberKind::I64 => loop {
-                let current = self.0.load(Ordering::Acquire);
-                let new = (current as i64).wrapping_add(val.0 as i64) as u64;
-                let swapped = self.0.compare_and_swap(current, new, Ordering::Release);
-                if swapped == current {
-                    return;
+            NumberKind::I64 => {
+                let mut old = self.0.load(Ordering::Acquire);
+                loop {
+                    let new = (old as i64).wrapping_add(val.0 as i64) as u64;
+                    match self.0.compare_exchange_weak(
+                        old,
+                        new,
+                        Ordering::AcqRel,
+                        Ordering::Acquire,
+                    ) {
+                        Ok(_) => break,
+                        Err(x) => old = x,
+                    };
                 }
-            },
-            NumberKind::F64 => loop {
-                let current = self.0.load(Ordering::Acquire);
-                let new = u64_to_f64(current) + u64_to_f64(val.0);
-                let swapped = self
-                    .0
-                    .compare_and_swap(current, f64_to_u64(new), Ordering::Release);
-                if swapped == current {
-                    return;
+            }
+            NumberKind::F64 => {
+                let mut old = self.0.load(Ordering::Acquire);
+                loop {
+                    let new = u64_to_f64(old) + u64_to_f64(val.0);
+                    match self.0.compare_exchange_weak(
+                        old,
+                        f64_to_u64(new),
+                        Ordering::AcqRel,
+                        Ordering::Acquire,
+                    ) {
+                        Ok(_) => break,
+                        Err(x) => old = x,
+                    };
                 }
-            },
+            }
             NumberKind::U64 => {
                 self.0.fetch_add(val.0, Ordering::AcqRel);
             }
@@ -122,24 +134,36 @@ impl AtomicNumber {
     /// `-inf` for `f64`.
     pub fn fetch_sub(&self, number_kind: &NumberKind, val: &Number) {
         match number_kind {
-            NumberKind::I64 => loop {
-                let current = self.0.load(Ordering::Acquire);
-                let new = (current as i64).wrapping_sub(val.0 as i64) as u64;
-                let swapped = self.0.compare_and_swap(current, new, Ordering::Release);
-                if swapped == current {
-                    return;
+            NumberKind::I64 => {
+                let mut old = self.0.load(Ordering::Acquire);
+                loop {
+                    let new = (old as i64).wrapping_sub(val.0 as i64) as u64;
+                    match self.0.compare_exchange_weak(
+                        old,
+                        new,
+                        Ordering::AcqRel,
+                        Ordering::Relaxed,
+                    ) {
+                        Ok(_) => break,
+                        Err(x) => old = x,
+                    };
                 }
-            },
-            NumberKind::F64 => loop {
-                let current = self.0.load(Ordering::Acquire);
-                let new = u64_to_f64(current) - u64_to_f64(val.0);
-                let swapped = self
-                    .0
-                    .compare_and_swap(current, f64_to_u64(new), Ordering::Release);
-                if swapped == current {
-                    return;
+            }
+            NumberKind::F64 => {
+                let mut old = self.0.load(Ordering::Acquire);
+                loop {
+                    let new = u64_to_f64(old) - u64_to_f64(val.0);
+                    match self.0.compare_exchange_weak(
+                        old,
+                        f64_to_u64(new),
+                        Ordering::AcqRel,
+                        Ordering::Acquire,
+                    ) {
+                        Ok(_) => break,
+                        Err(x) => old = x,
+                    };
                 }
-            },
+            }
             NumberKind::U64 => {
                 self.0.fetch_sub(val.0, Ordering::AcqRel);
             }