simplify retry interface

Author: scottgerring

opentelemetry-otlp/src/exporter/tonic/logs.rs

@@ -15,7 +15,7 @@ use opentelemetry_proto::transform::logs::tonic::group_logs_by_resource_and_scop
 use super::BoxInterceptor;
 
 use crate::retry_classification::grpc::classify_tonic_status;
-use opentelemetry_sdk::retry::{retry_with_exponential_backoff_classified, RetryPolicy};
+use opentelemetry_sdk::retry::{retry_with_backoff, RetryPolicy};
 use opentelemetry_sdk::runtime::Tokio;
 
 pub(crate) struct TonicLogsClient {
@@ -72,7 +72,7 @@ impl LogExporter for TonicLogsClient {
 
         let batch = Arc::new(batch);
 
-        match retry_with_exponential_backoff_classified(
+        match retry_with_backoff(
             Tokio,
             policy,
             classify_tonic_status,

opentelemetry-otlp/src/exporter/tonic/metrics.rs

@@ -13,7 +13,7 @@ use super::BoxInterceptor;
 use crate::metric::MetricsClient;
 
 use crate::retry_classification::grpc::classify_tonic_status;
-use opentelemetry_sdk::retry::{retry_with_exponential_backoff_classified, RetryPolicy};
+use opentelemetry_sdk::retry::{retry_with_backoff, RetryPolicy};
 use opentelemetry_sdk::runtime::Tokio;
 
 pub(crate) struct TonicMetricsClient {
@@ -64,7 +64,7 @@ impl MetricsClient for TonicMetricsClient {
             jitter_ms: 100,
         };
 
-        match retry_with_exponential_backoff_classified(
+        match retry_with_backoff(
             Tokio,
             policy,
             classify_tonic_status,

opentelemetry-otlp/src/exporter/tonic/trace.rs

@@ -17,7 +17,7 @@ use tonic::{codegen::CompressionEncoding, service::Interceptor, transport::Chann
 use super::BoxInterceptor;
 
 use crate::retry_classification::grpc::classify_tonic_status;
-use opentelemetry_sdk::retry::{retry_with_exponential_backoff_classified, RetryPolicy};
+use opentelemetry_sdk::retry::{retry_with_backoff, RetryPolicy};
 use opentelemetry_sdk::runtime::Tokio;
 
 pub(crate) struct TonicTracesClient {
@@ -74,7 +74,7 @@ impl SpanExporter for TonicTracesClient {
 
         let batch = Arc::new(batch);
 
-        match retry_with_exponential_backoff_classified(
+        match retry_with_backoff(
             Tokio,
             policy,
             classify_tonic_status,

opentelemetry-sdk/src/retry.rs

@@ -3,10 +3,10 @@
 //! The `RetryPolicy` struct defines the configuration for the retry behavior, including the maximum
 //! number of retries, initial delay, maximum delay, and jitter.
 //!
-//! The `retry_with_exponential_backoff` function retries the given operation according to the
+//! The `retry_with_backoff` function retries the given operation according to the
 //! specified retry policy, using exponential backoff and jitter to determine the delay between
-//! retries. The function logs errors and retries the operation until it succeeds or the maximum
-//! number of retries is reached.
+//! retries. The function uses error classification to determine retry behavior and can honor
+//! server-provided throttling hints.
 
 #[cfg(feature = "experimental_async_runtime")]
 use opentelemetry::otel_warn;
@@ -69,45 +69,7 @@ fn generate_jitter(max_jitter: u64) -> u64 {
     nanos as u64 % (max_jitter + 1)
 }
 
-/// Retries the given operation with exponential backoff and jitter.
-///
-/// # Arguments
-///
-/// * `runtime` - The async runtime to use for delays.
-/// * `policy` - The retry policy configuration.
-/// * `operation_name` - The name of the operation being retried.
-/// * `operation` - The operation to be retried.
-///
-/// # Returns
-///
-/// A `Result` containing the operation's result or an error if the maximum retries are reached.
-#[cfg(feature = "experimental_async_runtime")]
-pub async fn retry_with_exponential_backoff<R, F, Fut, T, E>(
-    runtime: R,
-    policy: RetryPolicy,
-    operation_name: &str,
-    operation: F,
-) -> Result<T, E>
-where
-    R: Runtime,
-    F: FnMut() -> Fut,
-    E: std::fmt::Debug,
-    Fut: Future<Output = Result<T, E>>,
-{
-    // Use a simple classifier that treats all errors as retryable
-    let simple_classifier = |_: &E| RetryErrorType::Retryable;
-
-    retry_with_exponential_backoff_classified(
-        runtime,
-        policy,
-        simple_classifier,
-        operation_name,
-        operation,
-    )
-    .await
-}
-
-/// Enhanced retry with exponential backoff, jitter, and error classification.
+/// Retries the given operation with exponential backoff, jitter, and error classification.
 ///
 /// This function provides sophisticated retry behavior by classifying errors
 /// and honoring server-provided throttling hints (e.g., HTTP Retry-After, gRPC RetryInfo).
@@ -125,7 +87,7 @@ where
 /// A `Result` containing the operation's result or an error if max retries are reached
 /// or a non-retryable error occurs.
 #[cfg(feature = "experimental_async_runtime")]
-pub async fn retry_with_exponential_backoff_classified<R, F, Fut, T, E, C>(
+pub async fn retry_with_backoff<R, F, Fut, T, E, C>(
     runtime: R,
     policy: RetryPolicy,
     error_classifier: C,
@@ -186,9 +148,10 @@ where
 /// No-op retry function for when experimental_async_runtime is not enabled.
 /// This function will execute the operation exactly once without any retries.
 #[cfg(not(feature = "experimental_async_runtime"))]
-pub async fn retry_with_exponential_backoff<R, F, Fut, T, E>(
+pub async fn retry_with_backoff<R, F, Fut, T, E, C>(
     _runtime: R,
     _policy: RetryPolicy,
+    _error_classifier: C,
     _operation_name: &str,
     mut operation: F,
 ) -> Result<T, E>
@@ -227,7 +190,7 @@ mod tests {
             jitter_ms: 100,
         };
 
-        let result = retry_with_exponential_backoff(runtime, policy, "test_operation", || {
+        let result = retry_with_backoff(runtime, policy, |_: &()| RetryErrorType::Retryable, "test_operation", || {
             Box::pin(async { Ok::<_, ()>("success") })
         })
         .await;
@@ -248,7 +211,7 @@ mod tests {
 
         let attempts = AtomicUsize::new(0);
 
-        let result = retry_with_exponential_backoff(runtime, policy, "test_operation", || {
+        let result = retry_with_backoff(runtime, policy, |_: &&str| RetryErrorType::Retryable, "test_operation", || {
             let attempt = attempts.fetch_add(1, Ordering::SeqCst);
             Box::pin(async move {
                 if attempt < 2 {
@@ -277,7 +240,7 @@ mod tests {
 
         let attempts = AtomicUsize::new(0);
 
-        let result = retry_with_exponential_backoff(runtime, policy, "test_operation", || {
+        let result = retry_with_backoff(runtime, policy, |_: &&str| RetryErrorType::Retryable, "test_operation", || {
             attempts.fetch_add(1, Ordering::SeqCst);
             Box::pin(async { Err::<(), _>("error") }) // Always fail
         })
@@ -300,7 +263,7 @@ mod tests {
 
         let result = timeout(
             Duration::from_secs(1),
-            retry_with_exponential_backoff(runtime, policy, "test_operation", || {
+            retry_with_backoff(runtime, policy, |_: &&str| RetryErrorType::Retryable, "test_operation", || {
                 Box::pin(async { Err::<(), _>("error") }) // Always fail
             }),
         )
@@ -337,7 +300,7 @@ mod tests {
         // Classifier that returns non-retryable
         let classifier = |_: &()| RetryErrorType::NonRetryable;
 
-        let result = retry_with_exponential_backoff_classified(
+        let result = retry_with_backoff(
             runtime,
             policy,
             classifier,
@@ -368,7 +331,7 @@ mod tests {
         // Classifier that returns retryable
         let classifier = |_: &()| RetryErrorType::Retryable;
 
-        let result = retry_with_exponential_backoff_classified(
+        let result = retry_with_backoff(
             runtime,
             policy,
             classifier,
@@ -407,7 +370,7 @@ mod tests {
 
         let start_time = std::time::Instant::now();
 
-        let result = retry_with_exponential_backoff_classified(
+        let result = retry_with_backoff(
             runtime,
             policy,
             classifier,
@@ -447,7 +410,7 @@ mod tests {
         // Classifier that returns retryable
         let classifier = |_: &()| RetryErrorType::Retryable;
 
-        let result = retry_with_exponential_backoff_classified(
+        let result = retry_with_backoff(
             runtime,
             policy,
             classifier,
@@ -482,7 +445,7 @@ mod tests {
             _ => RetryErrorType::Retryable,
         };
 
-        let result = retry_with_exponential_backoff_classified(
+        let result = retry_with_backoff(
             runtime,
             policy,
             classifier,