define an implicit getPrettySimpleName

This is most consistent with Java API, it adds
`obj.getClass.getPrettySimpleName` to the existing
`obj.getClass.get*Name`.

Instead we could go with a nicer `obj.prettyClassName`.

eclair-core/src/main/scala/fr/acinq/eclair/channel/Channel.scala

@@ -2143,15 +2143,15 @@ class Channel(val nodeParams: NodeParams, val wallet: OnChainChannelFunder, remo
   }
 
   private def handleAddHtlcCommandError(c: CMD_ADD_HTLC, cause: ChannelException, channelUpdate: Option[ChannelUpdate]) = {
-    log.warning(s"${cause.getMessage} while processing cmd=${c.getClass.getSimpleName} in state=$stateName")
+    log.warning(s"${cause.getMessage} while processing cmd=${c.getClass.getPrettySimpleName} in state=$stateName")
     val replyTo = if (c.replyTo == ActorRef.noSender) sender() else c.replyTo
     replyTo ! RES_ADD_FAILED(c, cause, channelUpdate)
     context.system.eventStream.publish(ChannelErrorOccurred(self, stateData.channelId, remoteNodeId, stateData, LocalError(cause), isFatal = false))
     stay()
   }
 
   private def handleCommandError(cause: ChannelException, c: channel.Command) = {
-    log.warning(s"${cause.getMessage} while processing cmd=${c.getClass.getSimpleName} in state=$stateName")
+    log.warning(s"${cause.getMessage} while processing cmd=${c.getClass.getPrettySimpleName} in state=$stateName")
     val replyTo_opt = c match {
       case hasOptionalReplyTo: HasOptionalReplyToCommand => hasOptionalReplyTo.replyTo_opt
       case hasReplyTo: HasReplyToCommand => if (hasReplyTo.replyTo == ActorRef.noSender) Some(sender()) else Some(hasReplyTo.replyTo)
@@ -2335,9 +2335,9 @@ class Channel(val nodeParams: NodeParams, val wallet: OnChainChannelFunder, remo
         log.warning(s"force-closing channel at user request")
       case _ if msg.exists(_.isInstanceOf[OpenChannel]) || msg.exists(_.isInstanceOf[AcceptChannel]) =>
         // invalid remote channel parameters are logged as warning
-        log.warning(s"${cause.getMessage} while processing msg=${msg.getOrElse("n/a").getClass.getSimpleName} in state=$stateName")
+        log.warning(s"${cause.getMessage} while processing msg=${msg.getOrElse("n/a").getClass.getPrettySimpleName} in state=$stateName")
       case _: ChannelException =>
-        log.error(s"${cause.getMessage} while processing msg=${msg.getOrElse("n/a").getClass.getSimpleName} in state=$stateName")
+        log.error(s"${cause.getMessage} while processing msg=${msg.getOrElse("n/a").getClass.getPrettySimpleName} in state=$stateName")
       case _ =>
         // unhandled error: we dump the channel data, and print the stack trace
         log.error(cause, s"msg=${msg.getOrElse("n/a")} stateData=$stateData:")
@@ -2724,7 +2724,7 @@ class Channel(val nodeParams: NodeParams, val wallet: OnChainChannelFunder, remo
   override val supervisorStrategy: OneForOneStrategy = OneForOneStrategy(loggingEnabled = true) { case _ => SupervisorStrategy.Escalate }
 
   override def aroundReceive(receive: Actor.Receive, msg: Any): Unit = {
-    KamonExt.time(ProcessMessage.withTag("MessageType", msg.getClass.getSimpleName)) {
+    KamonExt.time(ProcessMessage.withTag("MessageType", msg.getClass.getPrettySimpleName)) {
       super.aroundReceive(receive, msg)
     }
   }

eclair-core/src/main/scala/fr/acinq/eclair/crypto/TransportHandler.scala

@@ -28,7 +28,7 @@ import fr.acinq.eclair.crypto.ChaCha20Poly1305.ChaCha20Poly1305Error
 import fr.acinq.eclair.crypto.Noise._
 import fr.acinq.eclair.remote.EclairInternalsSerializer.RemoteTypes
 import fr.acinq.eclair.wire.protocol.{AnnouncementSignatures, RoutingMessage}
-import fr.acinq.eclair.{Diagnostics, FSMDiagnosticActorLogging, Logs, getSimpleClassName}
+import fr.acinq.eclair.{Diagnostics, FSMDiagnosticActorLogging, Logs, PrettySimpleClassName}
 import scodec.bits.ByteVector
 import scodec.{Attempt, Codec, DecodeResult}
 
@@ -263,7 +263,7 @@ class TransportHandler[T: ClassTag](keyPair: KeyPair, rs: Option[ByteVector], co
       case Event(msg, d) =>
         d match {
           case n: NormalData[T] => log.warning(s"unhandled message $msg in state normal unackedSent=${n.unackedSent.size} unackedReceived=${n.unackedReceived.size} sendBuffer.lowPriority=${n.sendBuffer.lowPriority.size} sendBuffer.normalPriority=${n.sendBuffer.normalPriority.size}")
-          case _ => log.warning(s"unhandled message $msg in state ${d.getClass.getSimpleName}")
+          case _ => log.warning(s"unhandled message $msg in state ${d.getClass.getPrettySimpleName}")
         }
         stay()
     }
@@ -277,7 +277,7 @@ class TransportHandler[T: ClassTag](keyPair: KeyPair, rs: Option[ByteVector], co
         stateData match {
           case normal: NormalData[_] =>
             // NB: we deduplicate on the class name: each class will appear once but there may be many instances (less verbose and gives debug hints)
-            log.info("stopping (unackedReceived={} unackedSent={})", normal.unackedReceived.keys.map(getSimpleClassName).toSet.mkString(","), normal.unackedSent.map(getSimpleClassName))
+            log.info("stopping (unackedReceived={} unackedSent={})", normal.unackedReceived.keys.map(_.getClass.getPrettySimpleName).toSet.mkString(","), normal.unackedSent.map(_.getClass.getPrettySimpleName))
           case _ =>
             log.info("stopping")
         }

eclair-core/src/main/scala/fr/acinq/eclair/db/pg/PgAuditDb.scala

@@ -273,7 +273,7 @@ class PgAuditDb(implicit ds: DataSource) extends AuditDb with Logging {
     inTransaction { pg =>
       using(pg.prepareStatement("INSERT INTO audit.channel_errors VALUES (?, ?, ?, ?, ?, ?)")) { statement =>
         val (errorName, errorMessage) = e.error match {
-          case LocalError(t) => (t.getClass.getSimpleName, t.getMessage)
+          case LocalError(t) => (t.getClass.getPrettySimpleName, t.getMessage)
           case RemoteError(error) => ("remote", error.toAscii)
         }
         statement.setString(1, e.channelId.toHex)

eclair-core/src/main/scala/fr/acinq/eclair/db/pg/PgPaymentsDb.scala

@@ -94,7 +94,7 @@ class PgPaymentsDb(implicit ds: DataSource, lock: PgLock) extends PaymentsDb wit
   }
 
   override def addOutgoingPayment(sent: OutgoingPayment): Unit = withMetrics("payments/add-outgoing", DbBackends.Postgres) {
-    require(sent.status == OutgoingPaymentStatus.Pending, s"outgoing payment isn't pending (${sent.status.getClass.getSimpleName})")
+    require(sent.status == OutgoingPaymentStatus.Pending, s"outgoing payment isn't pending (${sent.status.getClass.getPrettySimpleName})")
     withLock { pg =>
       using(pg.prepareStatement("INSERT INTO payments.sent (id, parent_id, external_id, payment_hash, payment_type, amount_msat, recipient_amount_msat, recipient_node_id, created_at, payment_request) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")) { statement =>
         statement.setString(1, sent.id.toString)

eclair-core/src/main/scala/fr/acinq/eclair/db/sqlite/SqliteAuditDb.scala

@@ -269,7 +269,7 @@ class SqliteAuditDb(sqlite: Connection) extends AuditDb with Logging {
   override def add(e: ChannelErrorOccurred): Unit = withMetrics("audit/add-channel-error", DbBackends.Sqlite) {
     using(sqlite.prepareStatement("INSERT INTO channel_errors VALUES (?, ?, ?, ?, ?, ?)")) { statement =>
       val (errorName, errorMessage) = e.error match {
-        case LocalError(t) => (t.getClass.getSimpleName, t.getMessage)
+        case LocalError(t) => (t.getClass.getPrettySimpleName, t.getMessage)
         case RemoteError(error) => ("remote", error.toAscii)
       }
       statement.setBytes(1, e.channelId.toArray)

eclair-core/src/main/scala/fr/acinq/eclair/db/sqlite/SqlitePaymentsDb.scala

@@ -121,7 +121,7 @@ class SqlitePaymentsDb(sqlite: Connection) extends PaymentsDb with Logging {
   }
 
   override def addOutgoingPayment(sent: OutgoingPayment): Unit = withMetrics("payments/add-outgoing", DbBackends.Sqlite) {
-    require(sent.status == OutgoingPaymentStatus.Pending, s"outgoing payment isn't pending (${sent.status.getClass.getSimpleName})")
+    require(sent.status == OutgoingPaymentStatus.Pending, s"outgoing payment isn't pending (${sent.status.getClass.getPrettySimpleName})")
     using(sqlite.prepareStatement("INSERT INTO sent_payments (id, parent_id, external_id, payment_hash, payment_type, amount_msat, recipient_amount_msat, recipient_node_id, created_at, payment_request) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")) { statement =>
       statement.setString(1, sent.id.toString)
       statement.setString(2, sent.parentId.toString)

eclair-core/src/main/scala/fr/acinq/eclair/json/JsonSerializers.scala

@@ -319,7 +319,7 @@ object PaymentFailedSummarySerializer extends ConvertClassSerializer[PaymentFail
 
 object ThrowableSerializer extends MinimalSerializer({
   case t: Throwable if t.getMessage != null => JString(t.getMessage)
-  case t: Throwable => JString(t.getClass.getSimpleName)
+  case t: Throwable => JString(t.getClass.getPrettySimpleName)
 })
 
 object FailureMessageSerializer extends MinimalSerializer({
@@ -400,7 +400,7 @@ object ChannelEventSerializer extends MinimalSerializer({
   case e: ChannelClosed => JObject(
     JField("type", JString("channel-closed")),
     JField("channelId", JString(e.channelId.toHex)),
-    JField("closingType", JString(e.closingType.getClass.getSimpleName))
+    JField("closingType", JString(e.closingType.getClass.getPrettySimpleName))
   )
 })
 

eclair-core/src/main/scala/fr/acinq/eclair/package.scala

@@ -138,9 +138,9 @@ package object eclair {
     // @formatter:on
   }
 
-  /**
-   * Apparently .getClass.getSimpleName can crash java 8 with a "Malformed class name" error
-   */
-  def getSimpleClassName(o: Any): String = o.getClass.getName.split("\\$").last
+  implicit class PrettySimpleClassName[T](private val o: Class[T]) extends AnyVal {
+    /** This removes trailing $ from `case object` class names */
+    def getPrettySimpleName: String = o.getSimpleName.replace("$", "")
+  }
 
 }

eclair-core/src/main/scala/fr/acinq/eclair/payment/Monitoring.scala

@@ -119,12 +119,12 @@ object Monitoring {
 
       def apply(cmdFail: CMD_FAIL_HTLC): String = cmdFail.reason match {
         case Left(_) => Remote
-        case Right(f) => f.getClass.getSimpleName
+        case Right(f) => f.getClass.getPrettySimpleName
       }
 
       def apply(pf: PaymentFailure): String = pf match {
-        case LocalFailure(_, _, t) => t.getClass.getSimpleName
-        case RemoteFailure(_, _, e) => e.failureMessage.getClass.getSimpleName
+        case LocalFailure(_, _, t) => t.getClass.getPrettySimpleName
+        case RemoteFailure(_, _, e) => e.failureMessage.getClass.getPrettySimpleName
         case UnreadableRemoteFailure(_, _) => "UnreadableRemoteFailure"
       }
     }

eclair-core/src/main/scala/fr/acinq/eclair/payment/receive/MultiPartHandler.scala

@@ -112,7 +112,7 @@ class MultiPartHandler(nodeParams: NodeParams, register: ActorRef, db: IncomingP
 
     case MultiPartPaymentFSM.MultiPartPaymentFailed(paymentHash, failure, parts) if doHandle(paymentHash) =>
       Logs.withMdc(log)(Logs.mdc(paymentHash_opt = Some(paymentHash))) {
-        Metrics.PaymentFailed.withTag(Tags.Direction, Tags.Directions.Received).withTag(Tags.Failure, failure.getClass.getSimpleName).increment()
+        Metrics.PaymentFailed.withTag(Tags.Direction, Tags.Directions.Received).withTag(Tags.Failure, failure.getClass.getPrettySimpleName).increment()
         log.warning("payment with paidAmount={} failed ({})", parts.map(_.amount).sum, failure)
         pendingPayments.get(paymentHash).foreach { case (_, handler: ActorRef) => handler ! PoisonPill }
         parts.collect {

eclair-core/src/main/scala/fr/acinq/eclair/payment/receive/MultiPartPaymentFSM.scala

@@ -99,7 +99,7 @@ class MultiPartPaymentFSM(nodeParams: NodeParams, paymentHash: ByteVector32, tot
           replyTo ! MultiPartPaymentSucceeded(paymentHash, parts)
           Metrics.ReceivedPaymentDuration.withTag(Tags.Success, value = true).record((TimestampMilli.now() - start).toMillis, TimeUnit.MILLISECONDS)
         case d =>
-          log.error("unexpected payment success data {}", d.getClass.getSimpleName)
+          log.error("unexpected payment success data {}", d.getClass.getPrettySimpleName)
       }
     case _ -> PAYMENT_FAILED =>
       nextStateData match {
@@ -108,7 +108,7 @@ class MultiPartPaymentFSM(nodeParams: NodeParams, paymentHash: ByteVector32, tot
           replyTo ! MultiPartPaymentFailed(paymentHash, failure, parts)
           Metrics.ReceivedPaymentDuration.withTag(Tags.Success, value = false).record((TimestampMilli.now() - start).toMillis, TimeUnit.MILLISECONDS)
         case d =>
-          log.error("unexpected payment failure data {}", d.getClass.getSimpleName)
+          log.error("unexpected payment failure data {}", d.getClass.getPrettySimpleName)
       }
   }
 

eclair-core/src/main/scala/fr/acinq/eclair/payment/receive/PaymentHandler.scala

@@ -38,7 +38,7 @@ class PaymentHandler(nodeParams: NodeParams, register: ActorRef) extends Actor w
 
   private def addReceiveHandler(handle: Receive): Receive = {
     case handler: ReceiveHandler =>
-      log.info(s"registering handler of type=${handler.getClass.getSimpleName}")
+      log.info(s"registering handler of type=${handler.getClass.getPrettySimpleName}")
       // NB: the last handler that was added will be the first called
       context become normal(handler.handle(context, log) orElse handle)
   }

eclair-core/src/main/scala/fr/acinq/eclair/payment/relay/ChannelRelay.scala

@@ -132,7 +132,7 @@ class ChannelRelay private(nodeParams: NodeParams,
         safeSendAndStop(o.add.channelId, cmdFail)
 
       case WrappedAddResponse(addFailed@RES_ADD_FAILED(CMD_ADD_HTLC(_, _, _, _, _, _: Origin.ChannelRelayedHot, _), _, _)) =>
-        context.log.info("attempt failed with reason={}", addFailed.t.getClass.getSimpleName)
+        context.log.info("attempt failed with reason={}", addFailed.t.getClass.getPrettySimpleName)
         context.self ! DoRelay
         relay(previousFailures :+ PreviouslyTried(selectedShortChannelId, addFailed))
 

eclair-core/src/main/scala/fr/acinq/eclair/payment/relay/NodeRelay.scala

@@ -187,7 +187,7 @@ class NodeRelay private(nodeParams: NodeParams,
         receiving(htlcs :+ add, nextPayload, nextPacket, handler)
       case WrappedMultiPartPaymentFailed(MultiPartPaymentFSM.MultiPartPaymentFailed(_, failure, parts)) =>
         context.log.warn("could not complete incoming multi-part payment (parts={} paidAmount={} failure={})", parts.size, parts.map(_.amount).sum, failure)
-        Metrics.recordPaymentRelayFailed(failure.getClass.getSimpleName, Tags.RelayType.Trampoline)
+        Metrics.recordPaymentRelayFailed(failure.getClass.getPrettySimpleName, Tags.RelayType.Trampoline)
         parts.collect { case p: MultiPartPaymentFSM.HtlcPart => rejectHtlc(p.htlc.id, p.htlc.channelId, p.amount, Some(failure)) }
         stopping()
       case WrappedMultiPartPaymentSucceeded(MultiPartPaymentFSM.MultiPartPaymentSucceeded(_, parts)) =>
@@ -319,7 +319,7 @@ class NodeRelay private(nodeParams: NodeParams,
   }
 
   private def rejectPayment(upstream: Upstream.Trampoline, failure: Option[FailureMessage]): Unit = {
-    Metrics.recordPaymentRelayFailed(failure.map(_.getClass.getSimpleName).getOrElse("Unknown"), Tags.RelayType.Trampoline)
+    Metrics.recordPaymentRelayFailed(failure.map(_.getClass.getPrettySimpleName).getOrElse("Unknown"), Tags.RelayType.Trampoline)
     upstream.adds.foreach(add => rejectHtlc(add.id, add.channelId, upstream.amountIn, failure))
   }
 

eclair-core/src/main/scala/fr/acinq/eclair/payment/relay/PostRestartHtlcCleaner.scala

@@ -136,7 +136,7 @@ class PostRestartHtlcCleaner(nodeParams: NodeParams, register: ActorRef, initial
       handleDownstreamFulfill(brokenHtlcs, o, htlc, fulfill.paymentPreimage)
 
     case RES_ADD_SETTLED(o: Origin.Cold, htlc, fail: HtlcResult.Fail) =>
-      log.info("htlc failed downstream: ({},{},{})", htlc.channelId, htlc.id, fail.getClass.getSimpleName)
+      log.info("htlc failed downstream: ({},{},{})", htlc.channelId, htlc.id, fail.getClass.getPrettySimpleName)
       handleDownstreamFailure(brokenHtlcs, o, htlc, fail)
 
     case GetBrokenHtlcs => sender() ! brokenHtlcs

eclair-core/src/main/scala/fr/acinq/eclair/remote/ScodecSerializer.scala

@@ -16,12 +16,12 @@
 
 package fr.acinq.eclair.remote
 
-import java.nio.ByteBuffer
-
 import akka.serialization.{ByteBufferSerializer, SerializerWithStringManifest}
 import scodec.Codec
 import scodec.bits.BitVector
 
+import java.nio.ByteBuffer
+
 class ScodecSerializer[T <: AnyRef](override val identifier: Int, codec: Codec[T]) extends SerializerWithStringManifest with ByteBufferSerializer {
 
   override def toBinary(o: AnyRef, buf: ByteBuffer): Unit = buf.put(toBinary(o))
@@ -33,7 +33,7 @@ class ScodecSerializer[T <: AnyRef](override val identifier: Int, codec: Codec[T
   }
 
   /** we don't rely on the manifest to provide backward compatibility, we will use dedicated codecs instead */
-  override def manifest(o: AnyRef): String = fr.acinq.eclair.getSimpleClassName(o)
+  override def manifest(o: AnyRef): String = o.getClass.getName
 
   override def toBinary(o: AnyRef): Array[Byte] = codec.encode(o.asInstanceOf[T]).require.toByteArray
 

eclair-core/src/main/scala/fr/acinq/eclair/router/Monitoring.scala

@@ -19,7 +19,7 @@ package fr.acinq.eclair.router
 import fr.acinq.bitcoin.{BtcDouble, MilliBtcDouble, SatoshiLong}
 import fr.acinq.eclair.router.Router.GossipDecision
 import fr.acinq.eclair.wire.protocol.ChannelUpdate
-import fr.acinq.eclair.{MilliSatoshi, getSimpleClassName}
+import fr.acinq.eclair.{MilliSatoshi, PrettySimpleClassName}
 import kamon.Kamon
 import kamon.metric.{Counter, MeasurementUnit}
 
@@ -64,7 +64,7 @@ object Monitoring {
 
     def gossipResult(decision: GossipDecision): Counter = decision match {
       case _: GossipDecision.Accepted => GossipResult.withTag("result", "accepted")
-      case rejected: GossipDecision.Rejected => GossipResult.withTag("result", "rejected").withTag("reason", getSimpleClassName(rejected))
+      case rejected: GossipDecision.Rejected => GossipResult.withTag("result", "rejected").withTag("reason", rejected.getClass.getPrettySimpleName)
     }
   }
 

eclair-core/src/main/scala/fr/acinq/eclair/router/RouteCalculation.scala

@@ -140,7 +140,7 @@ object RouteCalculation {
             ctx.sender() ! Status.Failure(failure)
           case Failure(t) =>
             val failure = if (isNeighborBalanceTooLow(d.graph, r)) BalanceTooLow else t
-            Metrics.FindRouteErrors.withTags(tags.withTag(Tags.Error, failure.getClass.getSimpleName)).increment()
+            Metrics.FindRouteErrors.withTags(tags.withTag(Tags.Error, failure.getClass.getPrettySimpleName)).increment()
             ctx.sender() ! Status.Failure(failure)
         }
       }

eclair-core/src/main/scala/fr/acinq/eclair/wire/protocol/LightningMessageCodecs.scala

@@ -389,14 +389,14 @@ object LightningMessageCodecs {
     discriminatorWithDefault(lightningMessageCodec, unknownMessageCodec.upcast)
 
   val meteredLightningMessageCodec = Codec[LightningMessage](
-    (msg: LightningMessage) => KamonExt.time(Metrics.EncodeDuration.withTag(Tags.MessageType, msg.getClass.getSimpleName))(lightningMessageCodecWithFallback.encode(msg)),
+    (msg: LightningMessage) => KamonExt.time(Metrics.EncodeDuration.withTag(Tags.MessageType, msg.getClass.getPrettySimpleName))(lightningMessageCodecWithFallback.encode(msg)),
     (bits: BitVector) => {
       // this is a bit more involved, because we don't know beforehand what the type of the message will be
       val begin = System.nanoTime()
       val res = lightningMessageCodecWithFallback.decode(bits)
       val end = System.nanoTime()
       val messageType = res match {
-        case Attempt.Successful(decoded) => decoded.value.getClass.getSimpleName
+        case Attempt.Successful(decoded) => decoded.value.getClass.getPrettySimpleName
         case Attempt.Failure(_) => "unknown"
       }
       Metrics.DecodeDuration.withTag(Tags.MessageType, messageType).record(end - begin)

eclair-core/src/test/scala/fr/acinq/eclair/PackageSpec.scala

@@ -109,18 +109,12 @@ class PackageSpec extends AnyFunSuite {
     assert(ShortChannelId(Long.MaxValue) < ShortChannelId(Long.MaxValue + 1))
   }
 
-  test("non-reg getSimpleName") {
-    /** We used to have this code due to crash issues on java 8 with a "Malformed class name" error */
-    def getSimpleClassName(o: Any): String = o.getClass.getName.split("\\$").last
-
-    // let's make sure that getSimpleClassName == getClass.getSimpleName even for nested classes and objects
-
-    List(
-      Foo(),
-      Foo.Bar,
-      Foo.Baz(42)
-    ).foreach { o =>
-      assert(getSimpleClassName(o) == o.getClass.getSimpleName)
+  test("non-reg getPrettySimpleName") {
+    Map(
+      Foo() -> "Foo",
+      Foo.Bar -> "Bar",
+      Foo.Baz(42) -> "Baz"
+    ).foreach { case (o, ref) => assert(o.getClass.getPrettySimpleName == ref)
     }
   }
 

eclair-front/src/main/scala/fr/acinq/eclair/Boot.scala

@@ -55,7 +55,7 @@ object Boot extends App with Logging {
   }
 
   def onError(t: Throwable): Unit = {
-    val errorMsg = if (t.getMessage != null) t.getMessage else t.getClass.getSimpleName
+    val errorMsg = if (t.getMessage != null) t.getMessage else t.getClass.getPrettySimpleName
     System.err.println(s"fatal error: $errorMsg")
     logger.error(s"fatal error: $errorMsg", t)
     sys.exit(1)