rename logging method

add static creators

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManager.java

@@ -100,7 +100,7 @@ protected SafeFuture<Void> publishMessageWithFeedback(final T message) {
         .handle(
             (__, err) -> {
               if (err != null) {
-                gossipFailureLogger.logWithSuppression(err, getSlotForMessage.apply(message));
+                gossipFailureLogger.log(err, getSlotForMessage.apply(message));
               } else {
                 LOG.trace(
                     "Successfully gossiped message with root {} on {}",

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AggregateGossipManager.java

@@ -55,7 +55,8 @@ public AggregateGossipManager(
         message -> Optional.of(message.getMessage().getAggregate().getData().getSlot()),
         message -> spec.computeEpochAtSlot(message.getMessage().getAggregate().getData().getSlot()),
         spec.getNetworkingConfig(),
-        new GossipFailureLogger(GossipTopicName.BEACON_AGGREGATE_AND_PROOF.toString(), true),
+        GossipFailureLogger.createSuppressing(
+            GossipTopicName.BEACON_AGGREGATE_AND_PROOF.toString()),
         debugDataDumper);
   }
 

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttestationGossipManager.java

@@ -33,7 +33,7 @@ public class AttestationGossipManager implements GossipManager {
   private final Counter attestationPublishFailureCounter;
 
   private final GossipFailureLogger gossipFailureLogger =
-      new GossipFailureLogger("attestation", true);
+      GossipFailureLogger.createSuppressing("attestation");
 
   public AttestationGossipManager(
       final MetricsSystem metricsSystem,
@@ -64,8 +64,7 @@ public void onNewAttestation(final ValidatableAttestation validatableAttestation
               attestationPublishSuccessCounter.inc();
             },
             error -> {
-              gossipFailureLogger.logWithSuppression(
-                  error, Optional.of(attestation.getData().getSlot()));
+              gossipFailureLogger.log(error, Optional.of(attestation.getData().getSlot()));
               attestationPublishFailureCounter.inc();
             });
   }

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/AttesterSlashingGossipManager.java

@@ -50,7 +50,7 @@ public AttesterSlashingGossipManager(
         message -> Optional.of(message.getAttestation1().getData().getSlot()),
         message -> spec.computeEpochAtSlot(message.getAttestation1().getData().getSlot()),
         spec.getNetworkingConfig(),
-        new GossipFailureLogger(GossipTopicName.ATTESTER_SLASHING.toString(), false),
+        GossipFailureLogger.createNonSuppressing(GossipTopicName.ATTESTER_SLASHING.toString()),
         debugDataDumper);
   }
 

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlobSidecarGossipManager.java

@@ -90,7 +90,7 @@ public static BlobSidecarGossipManager create(
         gossipNetwork,
         gossipEncoding,
         subnetIdToTopicHandler,
-        new GossipFailureLogger("blob_sidecar", false));
+        GossipFailureLogger.createNonSuppressing("blob_sidecar"));
   }
 
   private BlobSidecarGossipManager(
@@ -118,7 +118,7 @@ public SafeFuture<Void> publishBlobSidecar(final BlobSidecar message) {
         .handle(
             (__, err) -> {
               if (err != null) {
-                gossipFailureLogger.logWithSuppression(err, Optional.of(message.getSlot()));
+                gossipFailureLogger.log(err, Optional.of(message.getSlot()));
               } else {
                 LOG.trace(
                     "Successfully gossiped blob sidecar {} on {}",

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/BlockGossipManager.java

@@ -51,7 +51,7 @@ public BlockGossipManager(
         block -> Optional.of(block.getSlot()),
         block -> spec.computeEpochAtSlot(block.getSlot()),
         spec.getNetworkingConfig(),
-        new GossipFailureLogger(GossipTopicName.BEACON_BLOCK.toString(), false),
+        GossipFailureLogger.createNonSuppressing(GossipTopicName.BEACON_BLOCK.toString()),
         debugDataDumper);
   }
 

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLogger.java

@@ -31,13 +31,20 @@ public class GossipFailureLogger {
   private Optional<UInt64> lastErroredSlot;
   private Throwable lastRootCause;
 
-  public GossipFailureLogger(final String messageType, final boolean shouldSuppress) {
+  public static GossipFailureLogger createSuppressing(final String messageType) {
+    return new GossipFailureLogger(messageType, true);
+  }
+
+  public static GossipFailureLogger createNonSuppressing(final String messageType) {
+    return new GossipFailureLogger(messageType, false);
+  }
+
+  private GossipFailureLogger(final String messageType, final boolean shouldSuppress) {
     this.messageType = shouldSuppress ? messageType + "(s)" : messageType;
     this.shouldSuppress = shouldSuppress;
   }
 
-  public synchronized void logWithSuppression(
-      final Throwable error, final Optional<UInt64> maybeSlot) {
+  public synchronized void log(final Throwable error, final Optional<UInt64> maybeSlot) {
     final Throwable rootCause = Throwables.getRootCause(error);
 
     final boolean suppress;

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/ProposerSlashingGossipManager.java

@@ -51,7 +51,7 @@ public ProposerSlashingGossipManager(
                 .getSpec()
                 .computeEpochAtSlot(message.getHeader1().getMessage().getSlot()),
         networkingConfig,
-        new GossipFailureLogger(GossipTopicName.PROPOSER_SLASHING.toString(), false),
+        GossipFailureLogger.createNonSuppressing(GossipTopicName.PROPOSER_SLASHING.toString()),
         debugDataDumper);
   }
 

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedBlsToExecutionChangeGossipManager.java

@@ -53,7 +53,7 @@ public SignedBlsToExecutionChangeGossipManager(
         // of the topic they arrived on (ie disable fork checking at this level)
         message -> forkInfo.getFork().getEpoch(),
         networkingConfig,
-        new GossipFailureLogger(GossipTopicName.BLS_TO_EXECUTION_CHANGE.toString(), false),
+        GossipFailureLogger.createSuppressing(GossipTopicName.BLS_TO_EXECUTION_CHANGE.toString()),
         debugDataDumper);
   }
 

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SignedContributionAndProofGossipManager.java

@@ -54,8 +54,8 @@ public SignedContributionAndProofGossipManager(
                 .getSpec()
                 .computeEpochAtSlot(message.getMessage().getContribution().getSlot()),
         networkingConfig,
-        new GossipFailureLogger(
-            GossipTopicName.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF.toString(), true),
+        GossipFailureLogger.createSuppressing(
+            GossipTopicName.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF.toString()),
         debugDataDumper);
   }
 

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/SyncCommitteeMessageGossipManager.java

@@ -39,7 +39,7 @@ public class SyncCommitteeMessageGossipManager implements GossipManager {
   private final Counter publishFailureCounter;
 
   private final GossipFailureLogger gossipFailureLogger =
-      new GossipFailureLogger("sync_committee_message", true);
+      GossipFailureLogger.createSuppressing("sync_committee_message");
 
   public SyncCommitteeMessageGossipManager(
       final MetricsSystem metricsSystem,
@@ -109,7 +109,7 @@ private void publish(final SyncCommitteeMessage message, final int subnetId) {
               publishSuccessCounter.inc();
             },
             error -> {
-              gossipFailureLogger.logWithSuppression(error, Optional.of(message.getSlot()));
+              gossipFailureLogger.log(error, Optional.of(message.getSlot()));
               publishFailureCounter.inc();
             });
   }

networking/eth2/src/main/java/tech/pegasys/teku/networking/eth2/gossip/VoluntaryExitGossipManager.java

@@ -48,7 +48,7 @@ public VoluntaryExitGossipManager(
         exit -> Optional.empty(),
         exit -> exit.getMessage().getEpoch(),
         networkingConfig,
-        new GossipFailureLogger(GossipTopicName.VOLUNTARY_EXIT.toString(), false),
+        GossipFailureLogger.createNonSuppressing(GossipTopicName.VOLUNTARY_EXIT.toString()),
         debugDataDumper);
   }
 

networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/AbstractGossipManagerTest.java

@@ -184,7 +184,7 @@ protected TestGossipManager(
           message -> Optional.of(UInt64.ZERO),
           message -> UInt64.ZERO,
           networkingConfig,
-          new GossipFailureLogger(TOPIC_NAME.toString(), true),
+          GossipFailureLogger.createSuppressing(TOPIC_NAME.toString()),
           DebugDataDumper.NOOP);
     }
   }

networking/eth2/src/test/java/tech/pegasys/teku/networking/eth2/gossip/GossipFailureLoggerTest.java

@@ -13,6 +13,9 @@
 
 package tech.pegasys.teku.networking.eth2.gossip;
 
+import static tech.pegasys.teku.networking.eth2.gossip.GossipFailureLogger.createNonSuppressing;
+import static tech.pegasys.teku.networking.eth2.gossip.GossipFailureLogger.createSuppressing;
+
 import io.libp2p.core.SemiDuplexNoOutboundStreamException;
 import io.libp2p.pubsub.MessageAlreadySeenException;
 import io.libp2p.pubsub.NoPeersForOutboundMessageException;
@@ -31,13 +34,13 @@ class GossipFailureLoggerTest {
   public static final NoPeersForOutboundMessageException NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION =
       new NoPeersForOutboundMessageException("no peers");
 
-  private final GossipFailureLogger logger = new GossipFailureLogger("thingy", true);
-  private final GossipFailureLogger loggerNoSuppression = new GossipFailureLogger("thingy", false);
+  private final GossipFailureLogger loggerSuppressing = createSuppressing("thingy");
+  private final GossipFailureLogger loggerNoSuppression = createNonSuppressing("thingy");
 
   @Test
   void shouldLogAlreadySeenErrorsAtDebugLevel() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new RuntimeException("Foo", new MessageAlreadySeenException("Dupe")), SLOT);
       logCaptor.assertDebugLog(ALREADY_SEEN_MESSAGE);
     }
@@ -46,7 +49,7 @@ void shouldLogAlreadySeenErrorsAtDebugLevel() {
   @Test
   void shouldLogFirstNoPeersErrorsAtWarningLevel() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT);
       logCaptor.assertWarnLog(noPeersMessage(SLOT, true));
     }
@@ -55,19 +58,19 @@ void shouldLogFirstNoPeersErrorsAtWarningLevel() {
   @Test
   void shouldLogFirstNoActiveStreamErrorsAtWarningLevel() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(new RuntimeException("Foo", NO_ACTIVE_STREAM_EXCEPTION), SLOT);
+      loggerSuppressing.log(new RuntimeException("Foo", NO_ACTIVE_STREAM_EXCEPTION), SLOT);
       logCaptor.assertWarnLog(noActiveStreamMessage(SLOT, true));
     }
   }
 
   @Test
   void shouldLogRepeatedNoPeersErrorsAtDebugLevel() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT);
       logCaptor.clearLogs();
 
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT);
       logCaptor.assertDebugLog(noPeersMessage(SLOT, true));
     }
@@ -76,11 +79,11 @@ void shouldLogRepeatedNoPeersErrorsAtDebugLevel() {
   @Test
   void shouldLogRepeatedNoPeersErrorsWhenNoSuppression() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      loggerNoSuppression.logWithSuppression(
+      loggerNoSuppression.log(
           new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT);
       logCaptor.clearLogs();
 
-      loggerNoSuppression.logWithSuppression(
+      loggerNoSuppression.log(
           new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT);
       logCaptor.assertWarnLog(noPeersMessage(SLOT, false));
     }
@@ -89,11 +92,11 @@ void shouldLogRepeatedNoPeersErrorsWhenNoSuppression() {
   @Test
   void shouldLogNoPeersErrorsWithDifferentSlotsAtWarnLevel() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT);
       logCaptor.assertWarnLog(noPeersMessage(SLOT, true));
 
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION),
           Optional.of(UInt64.valueOf(2)));
       logCaptor.assertWarnLog(noPeersMessage(Optional.of(UInt64.valueOf(2)), true));
@@ -103,14 +106,14 @@ void shouldLogNoPeersErrorsWithDifferentSlotsAtWarnLevel() {
   @Test
   void shouldLogNoPeersErrorsAtWarnLevelWhenSeparatedByADifferentException() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT);
       logCaptor.assertWarnLog(noPeersMessage(SLOT, true));
       logCaptor.clearLogs();
 
-      logger.logWithSuppression(new MessageAlreadySeenException("Dupe"), SLOT);
+      loggerSuppressing.log(new MessageAlreadySeenException("Dupe"), SLOT);
 
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), SLOT);
       logCaptor.assertWarnLog(noPeersMessage(SLOT, true));
     }
@@ -119,20 +122,18 @@ void shouldLogNoPeersErrorsAtWarnLevelWhenSeparatedByADifferentException() {
   @Test
   void shouldLogFirstGenericErrorAtErrorLevel() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
-          new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT);
+      loggerSuppressing.log(new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT);
       logCaptor.assertErrorLog(genericError(SLOT, true));
     }
   }
 
   @Test
   void shouldLogRepeatedGenericErrorsAtDebugLevel() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
-          new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT);
+      loggerSuppressing.log(new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT);
       logCaptor.clearLogs();
 
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new IllegalStateException("Foo", new IllegalStateException("goes the dynamite")), SLOT);
       logCaptor.assertDebugLog(genericError(SLOT, true));
     }
@@ -141,12 +142,11 @@ void shouldLogRepeatedGenericErrorsAtDebugLevel() {
   @Test
   void shouldLogMultipleGenericErrorsWithDifferentCausesAtErrorLevel() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
-          new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT);
+      loggerSuppressing.log(new RuntimeException("Foo", new IllegalStateException("Boom")), SLOT);
       logCaptor.assertErrorLog(genericError(SLOT, true));
       logCaptor.clearLogs();
 
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new IllegalStateException("Foo", new IllegalArgumentException("goes the dynamite")),
           SLOT);
       logCaptor.assertErrorLog(genericError(SLOT, true));
@@ -156,11 +156,11 @@ void shouldLogMultipleGenericErrorsWithDifferentCausesAtErrorLevel() {
   @Test
   void shouldLogGenericErrorsWithoutSuppression() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new RuntimeException("Foo", new IllegalStateException("Boom")), Optional.empty());
       logCaptor.clearLogs();
 
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new IllegalStateException("Foo", new IllegalStateException("goes the dynamite")),
           Optional.empty());
       logCaptor.assertErrorLog(genericError(Optional.empty(), true));
@@ -170,11 +170,11 @@ void shouldLogGenericErrorsWithoutSuppression() {
   @Test
   void shouldLogNoPeersErrorsAtWarnLevelWithoutSuppression() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new RuntimeException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION), Optional.empty());
       logCaptor.clearLogs();
 
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new IllegalStateException("Foo", NO_PEERS_FOR_OUTBOUND_MESSAGE_EXCEPTION),
           Optional.empty());
       logCaptor.assertWarnLog(noPeersMessage(Optional.empty(), true));
@@ -184,11 +184,11 @@ void shouldLogNoPeersErrorsAtWarnLevelWithoutSuppression() {
   @Test
   void shouldLogNoActiveStreamErrorsWithoutSuppression() {
     try (final LogCaptor logCaptor = LogCaptor.forClass(GossipFailureLogger.class)) {
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new RuntimeException("Foo", NO_ACTIVE_STREAM_EXCEPTION), Optional.empty());
       logCaptor.clearLogs();
 
-      logger.logWithSuppression(
+      loggerSuppressing.log(
           new IllegalStateException("Foo", NO_ACTIVE_STREAM_EXCEPTION), Optional.empty());
       logCaptor.assertWarnLog(noActiveStreamMessage(Optional.empty(), true));
     }