factor out debug log methods into a class

Author: breedx-splk

disk-buffering/src/main/java/io/opentelemetry/contrib/disk/buffering/internal/exporter/FromDiskExporterImpl.java

@@ -8,25 +8,24 @@
 import io.opentelemetry.contrib.disk.buffering.internal.serialization.deserializers.SignalDeserializer;
 import io.opentelemetry.contrib.disk.buffering.internal.storage.Storage;
 import io.opentelemetry.contrib.disk.buffering.internal.storage.responses.ReadableResult;
+import io.opentelemetry.contrib.disk.buffering.internal.utils.DebugLogger;
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import java.io.IOException;
 import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
-import java.util.logging.Level;
 import java.util.logging.Logger;
 
 /**
  * Signal-type generic class that can read telemetry previously buffered on disk and send it to
  * another delegated exporter.
  */
 public final class FromDiskExporterImpl<EXPORT_DATA> implements FromDiskExporter {
-  private static final Logger logger = Logger.getLogger(FromDiskExporterImpl.class.getName());
+  private final DebugLogger logger;
   private final Storage storage;
   private final SignalDeserializer<EXPORT_DATA> deserializer;
   private final Function<Collection<EXPORT_DATA>, CompletableResultCode> exportFunction;
-  private final boolean debugEnabled;
 
   FromDiskExporterImpl(
       SignalDeserializer<EXPORT_DATA> deserializer,
@@ -36,7 +35,8 @@ public final class FromDiskExporterImpl<EXPORT_DATA> implements FromDiskExporter
     this.deserializer = deserializer;
     this.exportFunction = exportFunction;
     this.storage = storage;
-    this.debugEnabled = debugEnabled;
+    this.logger =
+        DebugLogger.wrap(Logger.getLogger(FromDiskExporterImpl.class.getName()), debugEnabled);
   }
 
   public static <T> FromDiskExporterBuilder<T> builder() {
@@ -54,30 +54,25 @@ public static <T> FromDiskExporterBuilder<T> builder() {
    */
   @Override
   public boolean exportStoredBatch(long timeout, TimeUnit unit) throws IOException {
-    log("Attempting to export " + deserializer.signalType() + " batch from disk.");
+    logger.log("Attempting to export " + deserializer.signalType() + " batch from disk.");
     ReadableResult result =
         storage.readAndProcess(
             bytes -> {
-              log(
+              logger.log(
                   "Read "
                       + bytes.length
                       + " "
                       + deserializer.signalType()
                       + " bytes from storage.");
               List<EXPORT_DATA> telemetry = deserializer.deserialize(bytes);
-              log("Now exporting batch of " + telemetry.size() + " " + deserializer.signalType());
+              logger.log(
+                  "Now exporting batch of " + telemetry.size() + " " + deserializer.signalType());
               CompletableResultCode join = exportFunction.apply(telemetry).join(timeout, unit);
               return join.isSuccess();
             });
     return result == ReadableResult.SUCCEEDED;
   }
 
-  private void log(String msg) {
-    if (debugEnabled) {
-      logger.log(Level.INFO, msg);
-    }
-  }
-
   @Override
   public void shutdown() throws IOException {
     storage.close();

disk-buffering/src/main/java/io/opentelemetry/contrib/disk/buffering/internal/exporter/ToDiskExporter.java

@@ -7,6 +7,7 @@
 
 import io.opentelemetry.contrib.disk.buffering.internal.serialization.serializers.SignalSerializer;
 import io.opentelemetry.contrib.disk.buffering.internal.storage.Storage;
+import io.opentelemetry.contrib.disk.buffering.internal.utils.DebugLogger;
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import java.io.IOException;
 import java.util.Collection;
@@ -16,11 +17,10 @@
 
 public class ToDiskExporter<EXPORT_DATA> {
 
-  private static final Logger logger = Logger.getLogger(ToDiskExporter.class.getName());
+  private final DebugLogger logger;
   private final Storage storage;
   private final SignalSerializer<EXPORT_DATA> serializer;
   private final Function<Collection<EXPORT_DATA>, CompletableResultCode> exportFunction;
-  private final boolean debugEnabled;
 
   ToDiskExporter(
       SignalSerializer<EXPORT_DATA> serializer,
@@ -30,42 +30,30 @@ public class ToDiskExporter<EXPORT_DATA> {
     this.serializer = serializer;
     this.exportFunction = exportFunction;
     this.storage = storage;
-    this.debugEnabled = debugEnabled;
+    this.logger = DebugLogger.wrap(Logger.getLogger(ToDiskExporter.class.getName()), debugEnabled);
   }
 
   public static <T> ToDiskExporterBuilder<T> builder() {
     return new ToDiskExporterBuilder<>();
   }
 
   public CompletableResultCode export(Collection<EXPORT_DATA> data) {
-    log("Intercepting exporter batch.", Level.FINER);
+    logger.log("Intercepting exporter batch.", Level.FINER);
     try {
       if (storage.write(serializer.serialize(data))) {
         return CompletableResultCode.ofSuccess();
       }
-      log("Could not store batch in disk. Exporting it right away.");
+      logger.log("Could not store batch in disk. Exporting it right away.");
       return exportFunction.apply(data);
     } catch (IOException e) {
-      if (debugEnabled) {
-        logger.log(
-            Level.WARNING,
-            "An unexpected error happened while attempting to write the data in disk. Exporting it right away.",
-            e);
-      }
+      logger.log(
+          "An unexpected error happened while attempting to write the data in disk. Exporting it right away.",
+          Level.WARNING,
+          e);
       return exportFunction.apply(data);
     }
   }
 
-  private void log(String msg) {
-    log(msg, Level.INFO);
-  }
-
-  private void log(String msg, Level level) {
-    if (debugEnabled) {
-      logger.log(level, msg);
-    }
-  }
-
   public void shutdown() throws IOException {
     storage.close();
   }

disk-buffering/src/main/java/io/opentelemetry/contrib/disk/buffering/internal/storage/Storage.java

@@ -12,27 +12,27 @@
 import io.opentelemetry.contrib.disk.buffering.internal.storage.files.WritableFile;
 import io.opentelemetry.contrib.disk.buffering.internal.storage.responses.ReadableResult;
 import io.opentelemetry.contrib.disk.buffering.internal.storage.responses.WritableResult;
+import io.opentelemetry.contrib.disk.buffering.internal.utils.DebugLogger;
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
-import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
 
 public final class Storage implements Closeable {
   private static final int MAX_ATTEMPTS = 3;
-  private static final Logger logger = Logger.getLogger(FromDiskExporterImpl.class.getName());
+  private final DebugLogger logger;
 
   private final FolderManager folderManager;
-  private final boolean debugEnabled;
   private final AtomicBoolean isClosed = new AtomicBoolean(false);
   @Nullable private WritableFile writableFile;
   @Nullable private ReadableFile readableFile;
 
   public Storage(FolderManager folderManager, boolean debugEnabled) {
     this.folderManager = folderManager;
-    this.debugEnabled = debugEnabled;
+    this.logger =
+        DebugLogger.wrap(Logger.getLogger(FromDiskExporterImpl.class.getName()), debugEnabled);
   }
 
   public static StorageBuilder builder() {
@@ -51,16 +51,16 @@ public boolean write(byte[] item) throws IOException {
 
   private boolean write(byte[] item, int attemptNumber) throws IOException {
     if (isClosed.get()) {
-      log("Refusing to write to storage after being closed.");
+      logger.log("Refusing to write to storage after being closed.");
       return false;
     }
     if (attemptNumber > MAX_ATTEMPTS) {
-      log("Max number of attempts to write buffered data exceeded.", WARNING);
+      logger.log("Max number of attempts to write buffered data exceeded.", WARNING);
       return false;
     }
     if (writableFile == null) {
       writableFile = folderManager.createWritableFile();
-      log("Created new writableFile: " + writableFile);
+      logger.log("Created new writableFile: " + writableFile);
     }
     WritableResult result = writableFile.append(item);
     if (result != WritableResult.SUCCEEDED) {
@@ -84,22 +84,22 @@ public ReadableResult readAndProcess(Function<byte[], Boolean> processing) throw
   private ReadableResult readAndProcess(Function<byte[], Boolean> processing, int attemptNumber)
       throws IOException {
     if (isClosed.get()) {
-      log("Refusing to read from storage after being closed.");
+      logger.log("Refusing to read from storage after being closed.");
       return ReadableResult.FAILED;
     }
     if (attemptNumber > MAX_ATTEMPTS) {
-      log("Maximum number of attempts to read and process buffered data exceeded.", WARNING);
+      logger.log("Maximum number of attempts to read and process buffered data exceeded.", WARNING);
       return ReadableResult.FAILED;
     }
     if (readableFile == null) {
-      log("Obtaining a new readableFile from the folderManager.");
+      logger.log("Obtaining a new readableFile from the folderManager.");
       readableFile = folderManager.getReadableFile();
       if (readableFile == null) {
-        log("Unable to get or create readable file.");
+        logger.log("Unable to get or create readable file.");
         return ReadableResult.FAILED;
       }
     }
-    log("Attempting to read data from " + readableFile);
+    logger.log("Attempting to read data from " + readableFile);
     ReadableResult result = readableFile.readAndProcess(processing);
     switch (result) {
       case SUCCEEDED:
@@ -112,19 +112,9 @@ private ReadableResult readAndProcess(Function<byte[], Boolean> processing, int
     }
   }
 
-  private void log(String msg) {
-    log(msg, Level.INFO);
-  }
-
-  private void log(String msg, Level level) {
-    if (debugEnabled) {
-      logger.log(level, msg);
-    }
-  }
-
   @Override
   public void close() throws IOException {
-    log("Closing disk buffering storage.");
+    logger.log("Closing disk buffering storage.");
     if (isClosed.compareAndSet(false, true)) {
       if (writableFile != null) {
         writableFile.close();

disk-buffering/src/main/java/io/opentelemetry/contrib/disk/buffering/internal/utils/DebugLogger.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.disk.buffering.internal.utils;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class DebugLogger {
+  private final Logger logger;
+  private final boolean debugEnabled;
+
+  private DebugLogger(Logger logger, boolean debugEnabled) {
+    this.logger = logger;
+    this.debugEnabled = debugEnabled;
+  }
+
+  public static DebugLogger wrap(Logger logger, boolean debugEnabled) {
+    return new DebugLogger(logger, debugEnabled);
+  }
+
+  public void log(String msg) {
+    log(msg, Level.INFO);
+  }
+
+  public void log(String msg, Level level) {
+    if (debugEnabled) {
+      logger.log(level, msg);
+    }
+  }
+
+  public void log(String msg, Level level, Throwable e) {
+    if (debugEnabled) {
+      logger.log(level, msg, e);
+    }
+  }
+}