leverage the usage of io.opentelemetry.sdk.common.export.RetryPolicy

instead of using individual values

Signed-off-by: Hilmar Falkenberg <[email protected]>

Author: hilmarf

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/AuditLogRecordProcessor.java

@@ -7,6 +7,7 @@
 
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.common.CompletableResultCode;
+import io.opentelemetry.sdk.common.export.RetryPolicy;
 import io.opentelemetry.sdk.logs.LogRecordProcessor;
 import io.opentelemetry.sdk.logs.ReadWriteLogRecord;
 import io.opentelemetry.sdk.logs.data.LogRecordData;
@@ -77,17 +78,8 @@ public static AuditLogRecordProcessorBuilder builder(
   /** The timeout for exporting logs in nanoseconds. */
   private final long timeout;
 
-  /** Maximum number of retry attempts for failed exports. */
-  private final int maxRetryAttempts;
-
-  /** Initial retry delay in milliseconds. */
-  private final long initialRetryDelayMillis;
-
-  /** Maximum retry delay in milliseconds to cap exponential backoff. */
-  private final long maxRetryDelayMillis;
-
-  /** Retry multiplier for exponential backoff. */
-  private final double retryMultiplier;
+  /** The retry policy for handling failed exports. */
+  private final RetryPolicy retryPolicy;
 
   /** Current retry attempt counter. */
   private final AtomicInteger currentRetryAttempt = new AtomicInteger(0);
@@ -107,10 +99,7 @@ public static AuditLogRecordProcessorBuilder builder(
    * @param scheduleDelayNanos the delay in nanoseconds between periodic exports.
    * @param maxExportBatchSize the maximum number of logs to export in a single batch.
    * @param exporterTimeoutNanos the timeout for exporting logs in nanoseconds.
-   * @param maxRetryAttempts the maximum number of retry attempts for failed exports.
-   * @param initialRetryDelayMillis the initial retry delay in milliseconds.
-   * @param maxRetryDelayMillis the maximum retry delay in milliseconds.
-   * @param retryMultiplier the retry multiplier for exponential backoff.
+   * @param retryPolicy the retry policy for handling failed exports.
    * @param waitOnExport whether to wait for the export to complete.
    */
   AuditLogRecordProcessor(
@@ -120,19 +109,13 @@ public static AuditLogRecordProcessorBuilder builder(
       long scheduleDelayNanos,
       int maxExportBatchSize,
       long exporterTimeoutNanos,
-      int maxRetryAttempts,
-      long initialRetryDelayMillis,
-      long maxRetryDelayMillis,
-      double retryMultiplier,
+      RetryPolicy retryPolicy,
       boolean waitOnExport) {
     exporter = logRecordExporter;
     size = maxExportBatchSize;
     timeout = exporterTimeoutNanos;
     handler = exceptionHandler;
-    this.maxRetryAttempts = maxRetryAttempts;
-    this.initialRetryDelayMillis = initialRetryDelayMillis;
-    this.maxRetryDelayMillis = maxRetryDelayMillis;
-    this.retryMultiplier = retryMultiplier;
+    this.retryPolicy = retryPolicy;
     this.waitOnExport = waitOnExport;
     queue =
         new PriorityBlockingQueue<>(
@@ -228,7 +211,7 @@ void exportLogs() {
     if (all.isDone() && !all.isSuccess()) {
       if (waitOnExport) {
         // Export failed, prepare for retry if attempts remain
-        if (currentRetryAttempt.getAndAdd(1) < maxRetryAttempts) {
+        if (currentRetryAttempt.getAndAdd(1) < retryPolicy.getMaxAttempts()) {
           lastRetryTimestamp.set(System.currentTimeMillis());
           queue.addAll(allFailedLogs);
           try {
@@ -274,10 +257,13 @@ private CompletableResultCode tryExport(Collection<LogRecordData> logs) {
    * @return delay in milliseconds
    */
   private long calculateRetryDelay(int attemptNumber) {
-    long delay = (long) (initialRetryDelayMillis * Math.pow(retryMultiplier, attemptNumber - 1));
+    long delay =
+        (long)
+            (retryPolicy.getInitialBackoff().toMillis()
+                * Math.pow(retryPolicy.getBackoffMultiplier(), attemptNumber - 1));
 
     // Cap the delay to maximum
-    delay = Math.min(delay, maxRetryDelayMillis);
+    delay = Math.min(delay, retryPolicy.getMaxBackoff().toMillis());
 
     // Add jitter to prevent thundering herd (±25% random variation)
     double jitter = 0.25 * delay * (Math.random() - 0.5);
@@ -298,7 +284,7 @@ private void handleExportFailure(
       handler.handle(new AuditException("Export failed", cause, failedLogs));
       return;
     }
-    if (currentRetryAttempt.get() < maxRetryAttempts) {
+    if (currentRetryAttempt.get() < retryPolicy.getMaxAttempts()) {
       // If retries haven't been exhausted, the retry logic will handle the next attempt
       return;
     }
@@ -311,7 +297,7 @@ private void handleExportFailure(
         String.format(
             Locale.ENGLISH,
             "Export failed after %d retry attempts. Last error: %s",
-            maxRetryAttempts,
+            retryPolicy.getMaxAttempts(),
             cause != null ? cause.getMessage() : "Unknown error");
 
     if (handler != null) {
@@ -425,6 +411,8 @@ public String toString() {
     builder.append(size);
     builder.append(", timeout=");
     builder.append(timeout);
+    builder.append(", retryPolicy=");
+    builder.append(retryPolicy);
     builder.append(", persistency=");
     builder.append(persistency);
     builder.append("]");

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/AuditLogRecordProcessorBuilder.java

@@ -8,12 +8,13 @@
 import static io.opentelemetry.api.internal.Utils.checkArgument;
 import static java.util.Objects.requireNonNull;
 
+import io.opentelemetry.sdk.common.export.RetryPolicy;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 /**
- * Builder class for {@link BatchLogRecordProcessor}.
+ * Builder class for {@link AuditLogRecordProcessor}.
  *
  * @since 1.27.0
  */
@@ -22,35 +23,21 @@ public final class AuditLogRecordProcessorBuilder {
   // Visible for testing
   public static final int DEFAULT_EXPORT_TIMEOUT_MILLIS = 30_000;
   // Visible for testing
-  public static final long DEFAULT_INITIAL_RETRY_DELAY_MILLIS = 1000;
-  // Visible for testing
   public static final int DEFAULT_MAX_EXPORT_BATCH_SIZE = 512;
   // Visible for testing
-  public static final int DEFAULT_MAX_RETRY_ATTEMPTS = 3;
-  // Visible for testing
-  public static final long DEFAULT_MAX_RETRY_DELAY_MILLIS = 30_000;
-  // Visible for testing
-  public static final double DEFAULT_RETRY_MULTIPLIER = 2.0;
-  // Visible for testing
   public static final long DEFAULT_SCHEDULE_DELAY_MILLIS = 1000;
 
   @Nullable private AuditExceptionHandler exceptionHandler;
 
   private long exporterTimeoutNanos = TimeUnit.MILLISECONDS.toNanos(DEFAULT_EXPORT_TIMEOUT_MILLIS);
 
-  private long initialRetryDelayMillis = DEFAULT_INITIAL_RETRY_DELAY_MILLIS;
-
   @Nonnull private final LogRecordExporter logRecordExporter;
 
   @Nonnull private final AuditLogStore logStore;
 
   private int maxExportBatchSize = DEFAULT_MAX_EXPORT_BATCH_SIZE;
 
-  private int maxRetryAttempts = DEFAULT_MAX_RETRY_ATTEMPTS;
-
-  private long maxRetryDelayMillis = DEFAULT_MAX_RETRY_DELAY_MILLIS;
-
-  private double retryMultiplier = DEFAULT_RETRY_MULTIPLIER;
+  private RetryPolicy retryPolicy = RetryPolicy.getDefault();
 
   private long scheduleDelayNanos = TimeUnit.MILLISECONDS.toNanos(DEFAULT_SCHEDULE_DELAY_MILLIS);
 
@@ -76,10 +63,7 @@ public AuditLogRecordProcessor build() {
         scheduleDelayNanos,
         maxExportBatchSize,
         exporterTimeoutNanos,
-        maxRetryAttempts,
-        initialRetryDelayMillis,
-        maxRetryDelayMillis,
-        retryMultiplier,
+        retryPolicy,
         waitOnExport);
   }
 
@@ -93,11 +77,6 @@ long getExporterTimeoutNanos() {
     return exporterTimeoutNanos;
   }
 
-  // Visible for testing
-  long getInitialRetryDelayMillis() {
-    return initialRetryDelayMillis;
-  }
-
   AuditLogStore getLogStore() {
     return logStore;
   }
@@ -108,18 +87,8 @@ int getMaxExportBatchSize() {
   }
 
   // Visible for testing
-  int getMaxRetryAttempts() {
-    return maxRetryAttempts;
-  }
-
-  // Visible for testing
-  long getMaxRetryDelayMillis() {
-    return maxRetryDelayMillis;
-  }
-
-  // Visible for testing
-  double getRetryMultiplier() {
-    return retryMultiplier;
+  RetryPolicy getRetryPolicy() {
+    return retryPolicy;
   }
 
   // Visible for testing
@@ -149,18 +118,6 @@ public AuditLogRecordProcessorBuilder setExporterTimeout(long timeout, @Nonnull
     return this;
   }
 
-  /**
-   * Sets the initial delay in milliseconds before the first retry attempt. If unset, defaults to
-   * {@value DEFAULT_INITIAL_RETRY_DELAY_MILLIS}ms.
-   */
-  public AuditLogRecordProcessorBuilder setInitialRetryDelay(
-      long initialRetryDelay, TimeUnit unit) {
-    requireNonNull(unit, "unit");
-    checkArgument(initialRetryDelay >= 0, "initialRetryDelay must be non-negative");
-    this.initialRetryDelayMillis = unit.toMillis(initialRetryDelay);
-    return this;
-  }
-
   /**
    * Sets the maximum batch size for every export. This must be smaller or equal to {@code
    * maxQueueSize}.
@@ -178,33 +135,15 @@ public AuditLogRecordProcessorBuilder setMaxExportBatchSize(int maxExportBatchSi
   }
 
   /**
-   * Sets the maximum number of retry attempts for failed exports. If unset, defaults to {@value
-   * DEFAULT_MAX_RETRY_ATTEMPTS}.
-   */
-  public AuditLogRecordProcessorBuilder setMaxRetryAttempts(int maxRetryAttempts) {
-    checkArgument(maxRetryAttempts >= 0, "maxRetryAttempts must be non-negative.");
-    this.maxRetryAttempts = maxRetryAttempts;
-    return this;
-  }
-
-  /**
-   * Sets the maximum delay in milliseconds between retry attempts. If unset, defaults to {@value
-   * DEFAULT_MAX_RETRY_DELAY_MILLIS}ms.
-   */
-  public AuditLogRecordProcessorBuilder setMaxRetryDelay(long maxRetryDelay, TimeUnit unit) {
-    requireNonNull(unit, "unit");
-    checkArgument(maxRetryDelay >= 0, "maxRetryDelay must be non-negative");
-    this.maxRetryDelayMillis = unit.toMillis(maxRetryDelay);
-    return this;
-  }
-
-  /**
-   * Sets the multiplier for increasing the retry delay after each failed attempt. If unset,
-   * defaults to {@value DEFAULT_RETRY_MULTIPLIER}.
+   * Sets the retry policy for failed exports. If unset, defaults to {@link
+   * RetryPolicy#getDefault()}.
+   *
+   * @param retryPolicy the retry policy to use for failed exports
+   * @return this
    */
-  public AuditLogRecordProcessorBuilder setRetryMultiplier(double retryMultiplier) {
-    checkArgument(retryMultiplier > 1.0, "retryMultiplier must be greater than 1.0");
-    this.retryMultiplier = retryMultiplier;
+  public AuditLogRecordProcessorBuilder setRetryPolicy(@Nonnull RetryPolicy retryPolicy) {
+    requireNonNull(retryPolicy, "retryPolicy");
+    this.retryPolicy = retryPolicy;
     return this;
   }
 

sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/AuditLogRecordProcessorTest.java

@@ -19,11 +19,13 @@
 
 import io.opentelemetry.internal.testing.slf4j.SuppressLogger;
 import io.opentelemetry.sdk.common.CompletableResultCode;
+import io.opentelemetry.sdk.common.export.RetryPolicy;
 import io.opentelemetry.sdk.logs.SdkLoggerProvider;
 import io.opentelemetry.sdk.logs.data.LogRecordData;
 import io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorTest.CompletableLogRecordExporter;
 import io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorTest.WaitingLogRecordExporter;
 import java.io.IOException;
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -87,6 +89,7 @@ void builderDefaults() {
         .isEqualTo(
             TimeUnit.MILLISECONDS.toNanos(
                 AuditLogRecordProcessorBuilder.DEFAULT_EXPORT_TIMEOUT_MILLIS));
+    assertThat(builder.getRetryPolicy()).isEqualTo(RetryPolicy.getDefault());
   }
 
   @Test
@@ -121,6 +124,12 @@ void builderInvalidConfig() {
                     .setMaxExportBatchSize(0))
         .isInstanceOf(IllegalArgumentException.class)
         .hasMessage("maxExportBatchSize must be positive.");
+    assertThatThrownBy(
+            () ->
+                AuditLogRecordProcessor.builder(mockLogRecordExporter, mockLogStore)
+                    .setRetryPolicy(null))
+        .isInstanceOf(NullPointerException.class)
+        .hasMessage("retryPolicy");
   }
 
   private void emitLog(SdkLoggerProvider sdkLoggerProvider, String message) {
@@ -335,14 +344,20 @@ void testRetry() throws Exception {
           assertThat(exception.logRecords).isNotEmpty();
         };
 
+    RetryPolicy retryPolicy =
+        RetryPolicy.builder()
+            .setMaxAttempts(3)
+            .setInitialBackoff(Duration.ofMillis(1))
+            .setMaxBackoff(Duration.ofMillis(1))
+            .build();
+
     AuditLogRecordProcessor processor =
         AuditLogRecordProcessor.builder(mockLogRecordExporter, logStore)
             .setScheduleDelay(MAX_SCHEDULE_DELAY_MILLIS, TimeUnit.MILLISECONDS)
             .setExceptionHandler(exceptionHandler)
             .setWaitOnExport(true) // enable waiting on export to ensure retries are attempted
             .setMaxExportBatchSize(1) // ensure each log is exported individually
-            .setMaxRetryAttempts(3) // set max retry attempts
-            .setMaxRetryDelay(1, TimeUnit.MILLISECONDS) // set retry delay
+            .setRetryPolicy(retryPolicy)
             .build();
     SdkLoggerProvider sdkLoggerProvider =
         SdkLoggerProvider.builder().addLogRecordProcessor(processor).build();
@@ -372,14 +387,20 @@ void testRetryFails() throws Exception {
           assertThat(exception.logRecords).isNotEmpty();
         };
 
+    RetryPolicy retryPolicy =
+        RetryPolicy.builder()
+            .setMaxAttempts(2) // Only 1 retry attempt (2 total attempts)
+            .setInitialBackoff(Duration.ofMillis(1))
+            .setMaxBackoff(Duration.ofMillis(1))
+            .build();
+
     AuditLogRecordProcessor processor =
         AuditLogRecordProcessor.builder(mockLogRecordExporter, logStore)
             .setScheduleDelay(MAX_SCHEDULE_DELAY_MILLIS, TimeUnit.MILLISECONDS)
             .setExceptionHandler(exceptionHandler)
             .setWaitOnExport(true) // enable waiting on export to ensure retries are attempted
             .setMaxExportBatchSize(1) // ensure each log is exported individually
-            .setMaxRetryAttempts(1) // set max retry attempts
-            .setMaxRetryDelay(1, TimeUnit.MILLISECONDS)
+            .setRetryPolicy(retryPolicy)
             .build();
     SdkLoggerProvider sdkLoggerProvider =
         SdkLoggerProvider.builder().addLogRecordProcessor(processor).build();