spotless

Author: jackshirazi

instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/config/OptionCallbackRegistry.java

@@ -5,7 +5,6 @@
 
 package io.opentelemetry.instrumentation.api.incubator.config;
 
-
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -16,24 +15,28 @@
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
 
-// MutableConfigProvider: If MutableConfigProvider was supported, this registry could be enhanced to:
-// - Register as a listener with the MutableConfigProvider to receive immediate notifications on config changes
-// - Eliminate the need for periodic polling (executor) and instead react to provider-driven change events
+// MutableConfigProvider: If MutableConfigProvider was supported, this registry could be enhanced
+// to:
+// - Register as a listener with the MutableConfigProvider to receive immediate notifications on
+// config changes
+// - Eliminate the need for periodic polling (executor) and instead react to provider-driven change
+// events
 // - Support dynamic config updates without the 30-second polling delay
 
 /**
  * Registry for callbacks that are invoked when configuration option values change.
  *
- * <p>This singleton can be loaded by multiple classloaders, creating separate instances that each monitor
- * the globally consistent System properties. For instances that don't need periodic checking (e.g., only
- * used for {@link #updateOption(String, String)}), {@link #shutdownPeriodicChecker()} can be called
- * to stop the background thread. Typically this would mean the extension that loads this class to use
- * {@link #updateOption(String, String)}) and no other capability of this class, should shutdown the
- * periodic checker during the extension initialization task. If this is not done, there are no adverse
- * effects other than the additional very low overhead thread.
+ * <p>This singleton can be loaded by multiple classloaders, creating separate instances that each
+ * monitor the globally consistent System properties. For instances that don't need periodic
+ * checking (e.g., only used for {@link #updateOption(String, String)}), {@link
+ * #shutdownPeriodicChecker()} can be called to stop the background thread. Typically this would
+ * mean the extension that loads this class to use {@link #updateOption(String, String)}) and no
+ * other capability of this class, should shutdown the periodic checker during the extension
+ * initialization task. If this is not done, there are no adverse effects other than the additional
+ * very low overhead thread.
  *
- * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change at
- * any time.
+ * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
+ * at any time.
  */
 public final class OptionCallbackRegistry {
 
@@ -47,8 +50,10 @@ public final class OptionCallbackRegistry {
   // Keep previous values so that only changes get notified
   private final Map<String, String> previousValues = new ConcurrentHashMap<>();
 
-  // MutableConfigProvider: This executor could be unnecessary if MutableConfigProvider was available,
-  // as we could register directly with the provider for immediate change notifications instead of polling
+  // MutableConfigProvider: This executor could be unnecessary if MutableConfigProvider was
+  // available,
+  // as we could register directly with the provider for immediate change notifications instead of
+  // polling
   private final ScheduledExecutorService executor =
       Executors.newSingleThreadScheduledExecutor(
           r -> {
@@ -75,23 +80,28 @@ public void shutdownPeriodicChecker() {
   }
 
   /**
-  * Registers a listener to be invoked when the value of the specified option key changes.
-  *
-  * <p>The listener receives the key and the new value. If the value becomes null, the listener is
-  * still invoked.
-  *
-  * <p>MutableConfigProvider: With MutableConfigProvider, this method would register the listener
-  * directly with the provider for the specific key, ensuring immediate notification of changes
-  * without relying on polling. 
-  *
-  * @param key the configuration key to monitor
-  * @param currentValue the current value of the key
-  * @param listener the listener to invoke on change
-  * @param isDeclarative if true, the currentValue is passed into {@link #updateOption(String, String)}. Where the config is declarative, this should be true, otherwise this should be false
-  */
-  public void registerCallback(String key, String currentValue, OptionChangeListener listener, boolean isDeclarative) {
-    // If instrumentations could be unloaded, we would wrap listeners in a WeakReference to prevent memory leaks:
-    // callbacks.computeIfAbsent(key, k -> new CopyOnWriteArrayList<>()).add(new WeakReference<>(listener));
+   * Registers a listener to be invoked when the value of the specified option key changes.
+   *
+   * <p>The listener receives the key and the new value. If the value becomes null, the listener is
+   * still invoked.
+   *
+   * <p>MutableConfigProvider: With MutableConfigProvider, this method would register the listener
+   * directly with the provider for the specific key, ensuring immediate notification of changes
+   * without relying on polling.
+   *
+   * @param key the configuration key to monitor
+   * @param currentValue the current value of the key
+   * @param listener the listener to invoke on change
+   * @param isDeclarative if true, the currentValue is passed into {@link #updateOption(String,
+   *     String)}. Where the config is declarative, this should be true, otherwise this should be
+   *     false
+   */
+  public void registerCallback(
+      String key, String currentValue, OptionChangeListener listener, boolean isDeclarative) {
+    // If instrumentations could be unloaded, we would wrap listeners in a WeakReference to prevent
+    // memory leaks:
+    // callbacks.computeIfAbsent(key, k -> new CopyOnWriteArrayList<>()).add(new
+    // WeakReference<>(listener));
 
     callbacks.computeIfAbsent(key, k -> new CopyOnWriteArrayList<>()).add(listener);
     if (isDeclarative) {
@@ -101,30 +111,32 @@ public void registerCallback(String key, String currentValue, OptionChangeListen
   }
 
   /**
-  * Updates the value of an option. Registered callbacks will be notified asynchronously
-  * when the periodic check detects the change.
-  *
-  * <p>MutableConfigProvider: If MutableConfigProvider was available, this method would be
-  * replaced by provider-driven updates. The MutableConfigProvider could notify this registry
-  * directly when configurations change, eliminating the need for manual updates via this method.
-  * Alternatively or additionally, this method could remain the primary runtime update mechanism,
-  * handling the required updates to MutableConfigProvider.
-  *
-  * @param key the option key
-  * @param value the new value, or {@code null} to remove the option
-  */
+   * Updates the value of an option. Registered callbacks will be notified asynchronously when the
+   * periodic check detects the change.
+   *
+   * <p>MutableConfigProvider: If MutableConfigProvider was available, this method would be replaced
+   * by provider-driven updates. The MutableConfigProvider could notify this registry directly when
+   * configurations change, eliminating the need for manual updates via this method. Alternatively
+   * or additionally, this method could remain the primary runtime update mechanism, handling the
+   * required updates to MutableConfigProvider.
+   *
+   * @param key the option key
+   * @param value the new value, or {@code null} to remove the option
+   */
   public void updateOption(String key, String value) {
     if (value != null) {
       // System.setProperty is thread-safe and provides consistent writes so no need to synchronize
       System.setProperty(key, value);
     } else {
       // Remove the property if value is null
-      // System.clearProperty is thread-safe and provides consistent writes so no need to synchronize
+      // System.clearProperty is thread-safe and provides consistent writes so no need to
+      // synchronize
       System.clearProperty(key);
     }
   }
 
-  // MutableConfigProvider: This polling method could be replaced by direct callback from MutableConfigProvider.
+  // MutableConfigProvider: This polling method could be replaced by direct callback from
+  // MutableConfigProvider.
   // The provider could call a method like onConfigChanged(String key, String newValue) directly,
   // eliminating the need to check all keys periodically and providing immediate updates.
   private void checkForChanges() {
@@ -152,7 +164,11 @@ private void notifyCallbacks(String key, @Nullable String newValue, @Nullable St
         try {
           listener.onOptionChanged(key, newValue, oldValue);
         } catch (Throwable t) {
-          logger.info("Warning, exception thrown when trying to notify listener for key '" + key + "': " + t.getMessage());
+          logger.info(
+              "Warning, exception thrown when trying to notify listener for key '"
+                  + key
+                  + "': "
+                  + t.getMessage());
         }
       }
     }