feat: expand INFO-level runtime logging for diagnostics

build.gradle.kts

@@ -1,6 +1,5 @@
 import com.ncorti.ktfmt.gradle.tasks.KtfmtCheckTask
 import com.ncorti.ktfmt.gradle.tasks.KtfmtFormatTask
-import com.vanniktech.maven.publish.SonatypeHost
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.api.tasks.testing.logging.TestLogEvent
 
@@ -57,7 +56,7 @@ kotlin {
 }
 
 mavenPublishing {
-    publishToMavenCentral(SonatypeHost.S01, true)
+    publishToMavenCentral(automaticRelease = true)
     signAllPublications()
 
     pom {

src/main/kotlin/io/cloudshiftdev/mavensync/MavenHttpClient.kt

@@ -37,13 +37,13 @@ internal class MavenHttpClient(
                 setBody(LocalFileContent(file))
             }
         val size = file.length()
-        logger.info { "Uploaded $url: status=${resp.status} size=$size" }
+        logger.debug { "Uploaded $url: status=${resp.status} size=$size" }
         return size
     }
 
     internal suspend fun upload(url: Url, content: String) {
         val resp = httpClient.put(url) { setBody(content) }
-        logger.info { "Uploaded $url: ${resp.status}" }
+        logger.debug { "Uploaded $url: ${resp.status}" }
     }
 
     internal suspend fun parseDirectoryListing(url: Url): List<Url> {

src/main/kotlin/io/cloudshiftdev/mavensync/MavenRepositoryCrawler.kt

@@ -33,7 +33,7 @@ internal class MavenRepositoryCrawler(
         url: Url,
         crawlDelay: Duration,
     ) {
-        logger.info { "Reading index: $url" }
+        logger.debug { "Reading index: $url" }
         val childLinks = httpClient.parseDirectoryListing(url)
 
         logger.debug { "Found ${childLinks.size} links in $url" }

src/main/kotlin/io/cloudshiftdev/mavensync/MavenSyncEngine.kt

@@ -39,19 +39,38 @@ internal class MavenSyncEngine(
         metrics.recordInSync(metadata.group, metadata.artifact, inSyncVersions)
 
         val missingVersions = sourceVersions - targetVersions
+        logger.info {
+            "Discovered ${metadata.group}:${metadata.artifact} — ${sourceVersions.size} versions" +
+                " in source, ${inSyncVersions.size} in sync, ${missingVersions.size} to sync"
+        }
+        inSyncVersions.forEach { version ->
+            logger.info { "In sync ${metadata.group}:${metadata.artifact}:${version.value}" }
+        }
         if (missingVersions.isEmpty()) {
             logger.debug { "No missing versions for ${metadata.group}:${metadata.artifact}" }
             return
         }
         logger.info {
             "Syncing missing versions for ${metadata.group}:${metadata.artifact}: $missingVersions"
         }
+        var synced = 0
+        var failed = 0
         missingVersions
             .map { Coordinates(metadata.group, metadata.artifact, it) }
-            .forEach { coordinates -> syncVersion(coordinates) }
+            .forEach { coordinates ->
+                when (syncVersion(coordinates)) {
+                    VersionOutcome.Synced -> synced++
+                    VersionOutcome.Failed -> failed++
+                    VersionOutcome.NoAssets -> Unit
+                }
+            }
+        logger.info {
+            "Completed ${metadata.group}:${metadata.artifact} —" +
+                " inSync=${inSyncVersions.size} synced=$synced failed=$failed"
+        }
     }
 
-    private suspend fun syncVersion(coordinates: Coordinates) {
+    private suspend fun syncVersion(coordinates: Coordinates): VersionOutcome {
         val mark = TimeSource.Monotonic.markNow()
         try {
             val assets =
@@ -61,25 +80,37 @@ internal class MavenSyncEngine(
                     options.transferSignatures,
                 )
 
-            if (assets.isEmpty()) return
+            if (assets.isEmpty()) return VersionOutcome.NoAssets
 
             var bytes = 0L
             assets.forEach { asset -> bytes += source.copyAsset(asset, target) }
             target.releaseVersion(coordinates)
+            val duration = mark.elapsedNow()
             metrics.recordSynced(
                 coordinates = coordinates,
                 assetCount = assets.size,
                 bytes = bytes,
-                duration = mark.elapsedNow(),
+                duration = duration,
             )
+            logger.info {
+                "Synced $coordinates — ${assets.size} assets, ${formatBytes(bytes)} in $duration"
+            }
 
             delay(options.downloadDelay)
+            return VersionOutcome.Synced
         } catch (e: CancellationException) {
             throw e
         } catch (e: Exception) {
             val msg = e.message ?: e.toString()
             logger.error(e) { "Failed to sync $coordinates: $msg" }
             metrics.recordFailure(coordinates, msg, mark.elapsedNow())
+            return VersionOutcome.Failed
         }
     }
+
+    private enum class VersionOutcome {
+        Synced,
+        Failed,
+        NoAssets,
+    }
 }

src/main/kotlin/io/cloudshiftdev/mavensync/MavenSyncMain.kt

@@ -25,7 +25,11 @@ public suspend fun main(args: Array<String>) {
 
     val config = loadConfiguration(args)
 
-    logger.info { "Effective configuration: $config" }
+    logger.info {
+        "Starting maven-sync: source=${config.source.url} target=${config.target.url} " +
+            "paths=${config.source.paths} concurrency=${config.artifactConcurrency}"
+    }
+    logger.debug { "Effective configuration: $config" }
 
     val metrics = SyncMetrics()
     try {
@@ -34,6 +38,7 @@ public suspend fun main(args: Array<String>) {
                 MavenSyncEngine(source, target, config.toSyncOptions(), metrics).sync()
             }
         }
+        logger.info { "Sync complete" }
     } finally {
         val report = metrics.snapshot()
         logger.info { "\n" + report.renderDetailed() }

src/main/kotlin/io/cloudshiftdev/mavensync/SyncMetrics.kt

@@ -141,7 +141,7 @@ internal data class SyncReport(val totalDuration: Duration, val artifacts: List<
     }
 }
 
-private fun formatBytes(bytes: Long): String {
+internal fun formatBytes(bytes: Long): String {
     if (bytes < 1024) return "$bytes B"
     val units = listOf("KB", "MB", "GB", "TB")
     var value = bytes.toDouble() / 1024.0