loadbalancer: better LoadBalancerFactory.toString() implementations

servicetalk-http-netty/src/main/java/io/servicetalk/http/netty/DefaultHttpLoadBalancerFactory.java

@@ -231,4 +231,12 @@ public String toString() {
             return delegate.toString();
         }
     }
+
+    @Override
+    public String toString() {
+        return "DefaultHttpLoadBalancerFactory{" +
+                "rawFactory=" + rawFactory +
+                ", strategy=" + strategy +
+                '}';
+    }
 }

servicetalk-loadbalancer-experimental/src/main/java/io/servicetalk/loadbalancer/CorePoolConnectionPoolStrategy.java

@@ -85,7 +85,31 @@ public C select(List<C> connections, Predicate<C> selector) {
 
     static <C extends LoadBalancedConnection> ConnectionPoolStrategyFactory<C> factory(
             int corePoolSize, boolean forceCorePool) {
-        ensurePositive(corePoolSize, "corePoolSize");
-        return (lbDesription) -> new CorePoolConnectionPoolStrategy<>(corePoolSize, forceCorePool);
+        return new CorePoolConnectionPoolStrategyFactory<>(corePoolSize, forceCorePool);
+    }
+
+    private static final class CorePoolConnectionPoolStrategyFactory<C extends LoadBalancedConnection>
+            implements ConnectionPoolStrategyFactory<C> {
+
+        private final int corePoolSize;
+        private final boolean forceCorePool;
+
+        CorePoolConnectionPoolStrategyFactory(int corePoolSize, boolean forceCorePool) {
+            this.corePoolSize = ensurePositive(corePoolSize, "corePoolSize");
+            this.forceCorePool = forceCorePool;
+        }
+
+        @Override
+        public ConnectionPoolStrategy<C> buildStrategy(String lbDescription) {
+            return new CorePoolConnectionPoolStrategy<>(corePoolSize, forceCorePool);
+        }
+
+        @Override
+        public String toString() {
+            return "CorePoolConnectionPoolStrategyFactory{" +
+                    "corePoolSize=" + corePoolSize +
+                    ", forceCorePool=" + forceCorePool +
+                    '}';
+        }
     }
 }

servicetalk-loadbalancer-experimental/src/main/java/io/servicetalk/loadbalancer/DefaultLoadBalancerBuilder.java

@@ -86,57 +86,33 @@ public LoadBalancerBuilder<ResolvedAddress, C> backgroundExecutor(Executor backg
 
     @Override
     public LoadBalancerFactory<ResolvedAddress, C> build() {
-        final HealthCheckConfig healthCheckConfig;
-        final Executor executor = getExecutor();
-        if (OutlierDetectorConfig.allDisabled(outlierDetectorConfig)) {
-            healthCheckConfig = null;
-        } else {
-            healthCheckConfig = new HealthCheckConfig(
-                    executor,
-                    outlierDetectorConfig.failureDetectorInterval(),
-                    outlierDetectorConfig.failureDetectorIntervalJitter(),
-                    outlierDetectorConfig.failedConnectionsThreshold(),
-                    outlierDetectorConfig.serviceDiscoveryResubscribeInterval(),
-                    outlierDetectorConfig.serviceDiscoveryResubscribeJitter());
-        }
-        final LoadBalancerObserverFactory loadBalancerObserverFactory = this.loadBalancerObserverFactory != null ?
-                this.loadBalancerObserverFactory : ignored -> NoopLoadBalancerObserver.instance();
-        final Function<String, OutlierDetector<ResolvedAddress, C>> outlierDetectorFactory;
-        if (OutlierDetectorConfig.xDSDisabled(outlierDetectorConfig)) {
-            outlierDetectorFactory = (lbDescription) -> new NoopOutlierDetector<>(outlierDetectorConfig, executor);
-        } else {
-            outlierDetectorFactory = (lbDescription) ->
-                new XdsOutlierDetector<>(executor, outlierDetectorConfig, lbDescription);
-        }
-        return new DefaultLoadBalancerFactory<>(id, loadBalancingPolicy, healthCheckConfig,
-                loadBalancerObserverFactory, outlierDetectorFactory, connectionPoolStrategyFactory);
+        return new DefaultLoadBalancerFactory<>(id, loadBalancingPolicy, loadBalancerObserverFactory,
+                connectionPoolStrategyFactory, outlierDetectorConfig, getExecutor());
     }
 
     static final class DefaultLoadBalancerFactory<ResolvedAddress, C extends LoadBalancedConnection>
             implements LoadBalancerFactory<ResolvedAddress, C> {
 
         private final String id;
         private final LoadBalancingPolicy<ResolvedAddress, C> loadBalancingPolicy;
-        private final LoadBalancerObserverFactory loadBalancerObserverFactory;
         @Nullable
-        private final Function<String, OutlierDetector<ResolvedAddress, C>> outlierDetectorFactory;
-        @Nullable
-        private final HealthCheckConfig healthCheckConfig;
+        private final LoadBalancerObserverFactory loadBalancerObserverFactory;
         private final ConnectionPoolStrategyFactory<C> connectionPoolStrategyFactory;
+        private final OutlierDetectorConfig outlierDetectorConfig;
+        private final Executor executor;
 
         DefaultLoadBalancerFactory(final String id, final LoadBalancingPolicy<ResolvedAddress, C> loadBalancingPolicy,
-                                   @Nullable final HealthCheckConfig healthCheckConfig,
-                                   final LoadBalancerObserverFactory loadBalancerObserverFactory,
-                                   final Function<String, OutlierDetector<ResolvedAddress, C>> outlierDetectorFactory,
-                                   final ConnectionPoolStrategyFactory<C> connectionPoolStrategyFactory) {
+                                   @Nullable final LoadBalancerObserverFactory loadBalancerObserverFactory,
+                                   final ConnectionPoolStrategyFactory<C> connectionPoolStrategyFactory,
+                                   final OutlierDetectorConfig outlierDetectorConfig,
+                                   final Executor executor) {
             this.id = requireNonNull(id, "id");
             this.loadBalancingPolicy = requireNonNull(loadBalancingPolicy, "loadBalancingPolicy");
-            this.loadBalancerObserverFactory = requireNonNull(loadBalancerObserverFactory,
-                    "loadBalancerObserverFactory");
+            this.loadBalancerObserverFactory = loadBalancerObserverFactory;
+            this.outlierDetectorConfig = requireNonNull(outlierDetectorConfig, "outlierDetectorConfig");
             this.connectionPoolStrategyFactory = requireNonNull(
                     connectionPoolStrategyFactory, "connectionPoolStrategyFactory");
-            this.healthCheckConfig = healthCheckConfig;
-            this.outlierDetectorFactory = outlierDetectorFactory;
+            this.executor = requireNonNull(executor, "executor");
         }
 
         @Override
@@ -159,6 +135,27 @@ public <T extends C> LoadBalancer<T> newLoadBalancer(
         public LoadBalancer<C> newLoadBalancer(
                 Publisher<? extends Collection<? extends ServiceDiscovererEvent<ResolvedAddress>>> eventPublisher,
                 ConnectionFactory<ResolvedAddress, C> connectionFactory, String targetResource) {
+            final HealthCheckConfig healthCheckConfig;
+            if (OutlierDetectorConfig.allDisabled(outlierDetectorConfig)) {
+                healthCheckConfig = null;
+            } else {
+                healthCheckConfig = new HealthCheckConfig(
+                        executor,
+                        outlierDetectorConfig.failureDetectorInterval(),
+                        outlierDetectorConfig.failureDetectorIntervalJitter(),
+                        outlierDetectorConfig.failedConnectionsThreshold(),
+                        outlierDetectorConfig.serviceDiscoveryResubscribeInterval(),
+                        outlierDetectorConfig.serviceDiscoveryResubscribeJitter());
+            }
+            final LoadBalancerObserverFactory loadBalancerObserverFactory = this.loadBalancerObserverFactory != null ?
+                    this.loadBalancerObserverFactory : NoopLoadBalancerObserver.factory();
+            final Function<String, OutlierDetector<ResolvedAddress, C>> outlierDetectorFactory;
+            if (OutlierDetectorConfig.xDSDisabled(outlierDetectorConfig)) {
+                outlierDetectorFactory = (lbDescription) -> new NoopOutlierDetector<>(outlierDetectorConfig, executor);
+            } else {
+                outlierDetectorFactory = (lbDescription) ->
+                    new XdsOutlierDetector<>(executor, outlierDetectorConfig, lbDescription);
+            }
             return new DefaultLoadBalancer<>(id, targetResource, eventPublisher,
                     DefaultHostPriorityStrategy::new, loadBalancingPolicy,
                     connectionPoolStrategyFactory, connectionFactory,
@@ -170,6 +167,18 @@ public ExecutionStrategy requiredOffloads() {
             // We do not block
             return ExecutionStrategy.offloadNone();
         }
+
+        @Override
+        public String toString() {
+            return "DefaultLoadBalancerFactory{" +
+                    "id='" + id + '\'' +
+                    ", loadBalancingPolicy=" + loadBalancingPolicy +
+                    ", loadBalancerObserverFactory=" + loadBalancerObserverFactory +
+                    ", connectionPoolStrategyFactory=" + connectionPoolStrategyFactory +
+                    ", outlierDetectorConfig=" + outlierDetectorConfig +
+                    ", executor=" + executor +
+                    '}';
+        }
     }
 
     private Executor getExecutor() {

servicetalk-loadbalancer-experimental/src/main/java/io/servicetalk/loadbalancer/LinearSearchConnectionPoolStrategy.java

@@ -91,7 +91,28 @@ public C select(List<C> connections, Predicate<C> selector) {
     }
 
     static <C extends LoadBalancedConnection> ConnectionPoolStrategyFactory<C> factory(final int linearSearchSpace) {
-        ensureNonNegative(linearSearchSpace, "linearSearchSpace");
-        return (lbDescription) -> new LinearSearchConnectionPoolStrategy<>(linearSearchSpace);
+        return new LinearSearchConnectionPoolStrategyFactory<>(linearSearchSpace);
+    }
+
+    private static final class LinearSearchConnectionPoolStrategyFactory<C extends LoadBalancedConnection>
+            implements ConnectionPoolStrategyFactory<C> {
+
+        private final int linearSearchSpace;
+
+        LinearSearchConnectionPoolStrategyFactory(final int linearSearchSpace) {
+            this.linearSearchSpace = ensureNonNegative(linearSearchSpace, "linearSearchSpace");
+        }
+
+        @Override
+        public ConnectionPoolStrategy<C> buildStrategy(String lbDescription) {
+            return new LinearSearchConnectionPoolStrategy<>(linearSearchSpace);
+        }
+
+        @Override
+        public String toString() {
+            return "LinearSearchConnectionPoolStrategyFactory{" +
+                    "linearSearchSpace=" + linearSearchSpace +
+                    '}';
+        }
     }
 }

servicetalk-loadbalancer-experimental/src/main/java/io/servicetalk/loadbalancer/NoopLoadBalancerObserver.java

@@ -23,6 +23,7 @@
 final class NoopLoadBalancerObserver implements LoadBalancerObserver {
 
     private static final LoadBalancerObserver INSTANCE = new NoopLoadBalancerObserver();
+    private static final LoadBalancerObserverFactory FACTORY_INSTANCE = new NoopLoadBalancerObserverFactory();
 
     private NoopLoadBalancerObserver() {
         // only private instance
@@ -87,7 +88,23 @@ public void onHostRevived() {
         }
     }
 
-    public static LoadBalancerObserver instance() {
+    static LoadBalancerObserver instance() {
         return INSTANCE;
     }
+
+    static LoadBalancerObserverFactory factory() {
+        return FACTORY_INSTANCE;
+    }
+
+    private static final class NoopLoadBalancerObserverFactory implements LoadBalancerObserverFactory {
+        @Override
+        public LoadBalancerObserver newObserver(String lbDescription) {
+            return INSTANCE;
+        }
+
+        @Override
+        public String toString() {
+            return "NoopLoadBalancerObserverFactory";
+        }
+    }
 }

servicetalk-loadbalancer-experimental/src/main/java/io/servicetalk/loadbalancer/OutlierDetectorConfig.java

@@ -319,6 +319,35 @@ public Duration ejectionTimeJitter() {
         return ejectionTimeJitter;
     }
 
+    @Override
+    public String toString() {
+        return "OutlierDetectorConfig{" +
+                "ewmaHalfLife=" + ewmaHalfLife +
+                ", ewmaCancellationPenalty=" + ewmaCancellationPenalty +
+                ", ewmaErrorPenalty=" + ewmaErrorPenalty +
+                ", cancellationIsError=" + cancellationIsError +
+                ", failedConnectionsThreshold=" + failedConnectionsThreshold +
+                ", failureDetectorIntervalJitter=" + failureDetectorIntervalJitter +
+                ", serviceDiscoveryResubscribeInterval=" + serviceDiscoveryResubscribeInterval +
+                ", serviceDiscoveryResubscribeJitter=" + serviceDiscoveryResubscribeJitter +
+                ", consecutive5xx=" + consecutive5xx +
+                ", failureDetectorInterval=" + failureDetectorInterval +
+                ", baseEjectionTime=" + baseEjectionTime +
+                ", ejectionTimeJitter=" + ejectionTimeJitter +
+                ", maxEjectionPercentage=" + maxEjectionPercentage +
+                ", enforcingConsecutive5xx=" + enforcingConsecutive5xx +
+                ", enforcingSuccessRate=" + enforcingSuccessRate +
+                ", successRateMinimumHosts=" + successRateMinimumHosts +
+                ", successRateRequestVolume=" + successRateRequestVolume +
+                ", successRateStdevFactor=" + successRateStdevFactor +
+                ", failurePercentageThreshold=" + failurePercentageThreshold +
+                ", enforcingFailurePercentage=" + enforcingFailurePercentage +
+                ", failurePercentageMinimumHosts=" + failurePercentageMinimumHosts +
+                ", failurePercentageRequestVolume=" + failurePercentageRequestVolume +
+                ", maxEjectionTime=" + maxEjectionTime +
+                '}';
+    }
+
     /**
      * A builder for {@link OutlierDetectorConfig} instances.
      */

servicetalk-loadbalancer-experimental/src/main/java/io/servicetalk/loadbalancer/P2CConnectionPoolStrategy.java

@@ -141,9 +141,35 @@ private C p2cPick(ThreadLocalRandom rnd, int randomSearchSpace, List<C> connecti
 
     static <C extends LoadBalancedConnection> ConnectionPoolStrategyFactory<C> factory(
             final int maxEffort, final int corePoolSize, final boolean forceCorePool) {
-        ensurePositive(maxEffort, " maxEffort");
-        ensureNonNegative(corePoolSize, "corePoolSize");
-        return (targetResource) -> new P2CConnectionPoolStrategy<>(
-                targetResource, maxEffort, corePoolSize, forceCorePool);
+        return new P2CConnectionPoolStrategyFactory<>(maxEffort, corePoolSize, forceCorePool);
+    }
+
+    private static final class P2CConnectionPoolStrategyFactory<C extends LoadBalancedConnection>
+            implements ConnectionPoolStrategyFactory<C> {
+
+        private final int maxEffort;
+        private final int corePoolSize;
+        private final boolean forceCorePool;
+
+        P2CConnectionPoolStrategyFactory(
+                final int maxEffort, final int corePoolSize, final boolean forceCorePool) {
+            this.maxEffort = ensurePositive(maxEffort, " maxEffort");
+            this.corePoolSize = ensureNonNegative(corePoolSize, "corePoolSize");
+            this.forceCorePool = forceCorePool;
+        }
+
+        @Override
+        public ConnectionPoolStrategy<C> buildStrategy(String lbDescription) {
+            return new P2CConnectionPoolStrategy<>(lbDescription, maxEffort, corePoolSize, forceCorePool);
+        }
+
+        @Override
+        public String toString() {
+            return "P2CConnectionPoolStrategyFactory{" +
+                    "maxEffort=" + maxEffort +
+                    ", corePoolSize=" + corePoolSize +
+                    ", forceCorePool=" + forceCorePool +
+                    '}';
+        }
     }
 }

servicetalk-loadbalancer-experimental/src/main/java/io/servicetalk/loadbalancer/P2CLoadBalancingPolicy.java

@@ -67,6 +67,11 @@ public String name() {
 
     @Override
     public String toString() {
-        return name() + "(failOpen=" + failOpen + ", maxEffort=" + maxEffort + ')';
+        return "P2CLoadBalancingPolicy{" +
+                "ignoreWeights=" + ignoreWeights +
+                ", maxEffort=" + maxEffort +
+                ", failOpen=" + failOpen +
+                ", random=" + random +
+                '}';
     }
 }

servicetalk-loadbalancer-experimental/src/main/java/io/servicetalk/loadbalancer/RoundRobinLoadBalancingPolicy.java

@@ -53,6 +53,9 @@ public String name() {
 
     @Override
     public String toString() {
-        return name() + "(failOpen=" + failOpen + ")";
+        return "RoundRobinLoadBalancingPolicy{" +
+                "failOpen=" + failOpen +
+                ", ignoreWeights=" + ignoreWeights +
+                '}';
     }
 }

servicetalk-loadbalancer-experimental/src/test/java/io/servicetalk/loadbalancer/DefaultLoadBalancerBuilderTest.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2024 Apple Inc. and the ServiceTalk project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.servicetalk.loadbalancer;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.startsWith;
+
+final class DefaultLoadBalancerBuilderTest {
+
+    @Test
+    void isTheResultOfLoadBalancersBuilder() {
+        LoadBalancerBuilder<String, TestLoadBalancedConnection> builder = LoadBalancers.builder("builder_id");
+        assertThat(builder, instanceOf(DefaultLoadBalancerBuilder.class));
+    }
+
+    @Test
+    void toStringWorks() {
+        DefaultLoadBalancerBuilder<String, TestLoadBalancedConnection> builder =
+                new DefaultLoadBalancerBuilder<>("builder_id");
+        // Make sure the `.toString()` method doesn't throw due to being recursive or something similar.
+        assertThat(builder.build().toString(), startsWith(
+        "DefaultLoadBalancerFactory{" +
+                "id='builder_id', "));
+    }
+}

servicetalk-loadbalancer-experimental/src/test/java/io/servicetalk/loadbalancer/DefaultLoadBalancerTest.java

@@ -238,7 +238,7 @@ TestableLoadBalancer<String, TestLoadBalancedConnection> newTestLoadBalancer(
                 loadBalancingPolicy,
                 LinearSearchConnectionPoolStrategy.factory(DEFAULT_LINEAR_SEARCH_SPACE),
                 connectionFactory,
-                lbDescription -> NoopLoadBalancerObserver.instance(),
+                NoopLoadBalancerObserver.factory(),
                 null,
                 factory);
     }