chore(logging): improve debug and error messages for artifact code handling

ashleycaselli · ashleycaselli · commit 56a3efbfae3a · 2026-06-22T19:21:17.000+02:00
diff --git a/src/main/java/net/trustyuri/ArtifactCodeImpl.java b/src/main/java/net/trustyuri/ArtifactCodeImpl.java
@@ -25,8 +25,9 @@ public class ArtifactCodeImpl implements ArtifactCode {
         if (TrustyUriUtils.isPotentialArtifactCode(artifactCode)) {
             this.dataHash = TrustyUriUtils.getDataPart(artifactCode);
             this.module = ModuleDirectory.getModule(TrustyUriUtils.getModuleId(artifactCode));
+            logger.debug("Created ArtifactCodeImpl from code '{}': module='{}', dataHash='{}'", artifactCode, module.getModuleId(), dataHash);
         } else {
-            logger.error("Invalid artifact code: {}", artifactCode);
+            logger.error("Invalid artifact code (failed format/length check): '{}'", artifactCode);
             throw new IllegalArgumentException("Invalid artifact code: " + artifactCode);
         }
     }
@@ -39,19 +40,20 @@ public class ArtifactCodeImpl implements ArtifactCode {
      */
     ArtifactCodeImpl(TrustyUriModule module, String dataHash) {
         if (module == null) {
-            logger.error("Module cannot be null");
+            logger.error("Cannot create artifact code: module is null (dataHash='{}')", dataHash);
             throw new IllegalArgumentException("Module cannot be null");
         }
         if (dataHash == null || dataHash.isEmpty()) {
-            logger.error("Data hash cannot be null or empty");
+            logger.error("Cannot create artifact code: data hash is null or empty (module='{}')", module.getModuleId());
             throw new IllegalArgumentException("Data hash cannot be null or empty");
         }
         if (module.getDataPartLength() != dataHash.length()) {
-            logger.error("Data hash length does not match module requirements: expected {}, got {}", module.getDataPartLength(), dataHash.length());
+            logger.error("Cannot create artifact code for module '{}': data hash '{}' has length {}, expected {}", module.getModuleId(), dataHash, dataHash.length(), module.getDataPartLength());
             throw new IllegalArgumentException("Data hash length does not match module requirements: expected " + module.getDataPartLength() + ", got " + dataHash.length());
         }
         this.module = module;
         this.dataHash = dataHash;
+        logger.debug("Created ArtifactCodeImpl: module='{}', dataHash='{}'", module.getModuleId(), dataHash);
     }
 
     @Override
diff --git a/src/main/java/net/trustyuri/TrustyUriResource.java b/src/main/java/net/trustyuri/TrustyUriResource.java
@@ -120,7 +120,11 @@ public TrustyUriResource(URL url, String artifactCode) throws IOException {
         logger.debug("Creating TrustyUriResource from URL '{}' with explicit artifact code '{}'", url, artifactCode);
         URLConnection conn = url.openConnection();
         String contentType = conn.getContentType();
-        logger.debug("Content-Type reported by server for '{}': '{}'", url, contentType);
+        if (contentType == null) {
+            logger.warn("Server did not report a Content-Type for URL '{}'; mimetype will be unknown", url);
+        } else {
+            logger.debug("Content-Type reported by server for '{}': '{}'", url, contentType);
+        }
         init(url.toString(), contentType, conn.getInputStream(), artifactCode);
     }
 
@@ -136,7 +140,11 @@ public TrustyUriResource(URL url) throws IOException {
         logger.debug("Creating TrustyUriResource from URL '{}'; derived artifact code: '{}'", n, ac);
         URLConnection conn = url.openConnection();
         String contentType = conn.getContentType();
-        logger.debug("Content-Type reported by server for '{}': '{}'", n, contentType);
+        if (contentType == null) {
+            logger.warn("Server did not report a Content-Type for URL '{}'; mimetype will be unknown", n);
+        } else {
+            logger.debug("Content-Type reported by server for '{}': '{}'", n, contentType);
+        }
         init(n, contentType, conn.getInputStream(), ac);
     }
 
@@ -145,11 +153,17 @@ private void init(String filename, String mimetype, InputStream in, String artif
         this.mimetype = mimetype;
         this.artifactCode = artifactCode;
         if (filename.matches(".*\\.(gz|gzip)")) {
-            logger.debug("Detected compressed resource '{}', wrapping stream in GZIPInputStream", filename);
-            this.in = new GZIPInputStream(in);
+            logger.debug("Detected compressed resource '{}' (.gz/.gzip extension), wrapping stream in GZIPInputStream", filename);
+            try {
+                this.in = new GZIPInputStream(in);
+            } catch (IOException ex) {
+                logger.error("Failed to read '{}' as a GZIP stream despite .gz/.gzip extension: {}", filename, ex.getMessage());
+                throw ex;
+            }
         } else {
             this.in = in;
         }
+        logger.debug("Initialized TrustyUriResource: filename='{}', mimetype='{}', artifactCode='{}', compressed={}", filename, mimetype, artifactCode, compressed);
     }
 
     /**
@@ -212,7 +226,9 @@ public boolean isCompressed() {
      * @return the module identifier of the resource, which is derived from the artifact code
      */
     public String getModuleId() {
-        return TrustyUriUtils.getModuleId(artifactCode);
+        String moduleId = TrustyUriUtils.getModuleId(artifactCode);
+        logger.debug("Resolved module ID for artifact code '{}': '{}'", artifactCode, moduleId);
+        return moduleId;
     }
 
     /**
diff --git a/src/main/java/net/trustyuri/TrustyUriUtils.java b/src/main/java/net/trustyuri/TrustyUriUtils.java
@@ -122,6 +122,10 @@ public static String getNiUri(String s, boolean withAuthority) {
         // TODO For future modules, hash might not be equal to data part:
         String hash = getDataPart(ac);
         TrustyUriModule module = ModuleDirectory.getModule(moduleId);
+        if (module == null) {
+            logger.warn("Cannot convert to ni URI — no module registered for ID '{}' (artifact code '{}', from '{}')", moduleId, ac, s);
+            return null;
+        }
         String tail = "/" + module.getAlgorithmId() + ";" + hash + "?module=" + moduleId;
         if (withAuthority) {
             try {
@@ -161,7 +165,9 @@ public static String getBase64(byte[] bytes) {
     public static String getBase64Hash(String s) {
         MessageDigest md = RdfHasher.getDigest();
         md.update(s.getBytes());
-        return getBase64(md.digest());
+        String hash = getBase64(md.digest());
+        logger.debug("Computed base64 hash for string of length {}: '{}'", s.length(), hash);
+        return hash;
     }
 
     /**
diff --git a/src/main/java/net/trustyuri/file/FileHasher.java b/src/main/java/net/trustyuri/file/FileHasher.java
@@ -35,21 +35,31 @@ public FileHasher() {
      * @throws IOException if an I/O error occurs while reading the input stream
      */
     public ArtifactCode makeArtifactCode(InputStream in) throws IOException {
-        logger.debug("Computing {} artifact code from input stream", HASH_ALGORITHM);
-        MessageDigest md = null;
+        logger.debug("Starting {} hash computation from input stream", HASH_ALGORITHM);
+        MessageDigest md;
         try {
             md = MessageDigest.getInstance(HASH_ALGORITHM);
         } catch (NoSuchAlgorithmException ex) {
+            logger.error("{} algorithm not available on this JVM", HASH_ALGORITHM, ex);
             throw new IllegalStateException(HASH_ALGORITHM + " algorithm not available on this JVM", ex);
         }
+
+        long bytesRead = 0;
         DigestInputStream d = null;
         try {
             d = new DigestInputStream(in, md);
             while (d.read() != -1) {
+                bytesRead++;
             }
+        } catch (IOException ex) {
+            logger.error("I/O error while hashing input stream after {} byte(s) read", bytesRead, ex);
+            throw ex;
         } finally {
             d.close();
         }
+
+        logger.debug("Read and hashed {} byte(s) from input stream", bytesRead);
+
         ArtifactCode code = ArtifactCode.of(ModuleDirectory.getModule(FileModule.MODULE_ID), TrustyUriUtils.getBase64(md.digest()));
         logger.debug("Computed artifact code: {}", code);
         return code;
diff --git a/src/main/java/net/trustyuri/file/FileModule.java b/src/main/java/net/trustyuri/file/FileModule.java
@@ -41,32 +41,40 @@ public int getDataPartLength() {
 
     @Override
     public boolean hasCorrectHash(TrustyUriResource r) throws IOException {
-        logger.debug("Verifying hash for resource: {}", r);
+        logger.debug("Verifying hash for resource '{}' (claimed artifact code: '{}')", r.getFilename(), r.getArtifactCode());
         FileHasher hasher = new FileHasher();
         ArtifactCode ac = hasher.makeArtifactCode(new BufferedInputStream(r.getInputStream()));
         boolean matches = r.getArtifactCode().equals(ac.toString());
         if (matches) {
-            logger.debug("Hash verification passed for resource: {}", r);
+            logger.debug("Hash verification passed for resource '{}'", r.getFilename());
         } else {
-            logger.warn("Hash verification FAILED for resource: {} — expected {}, got {}",
-                    r, r.getArtifactCode(), ac);
+            logger.warn("Hash verification FAILED for resource '{}' — claimed '{}', actual computed hash '{}'", r.getFilename(), r.getArtifactCode(), ac);
         }
         return matches;
     }
 
     @Override
     public void fixTrustyFile(File file) throws IOException {
         logger.info("Fixing trusty URI filename for: {}", file.getAbsolutePath());
+
         TrustyUriResource r = new TrustyUriResource(file);
+        String artifactCode = r.getArtifactCode();
+        if (artifactCode == null || artifactCode.isEmpty()) {
+            logger.warn("No artifact code derived from filename '{}'; nothing to strip before reprocessing", r.getFilename());
+        }
+
         File renamedFile = new File(r.getFilename().replaceAll(r.getArtifactCode(), ""));
-        logger.debug("Stripping artifact code '{}' — renaming to: {}", r.getArtifactCode(), renamedFile.getName());
+        logger.debug("Stripping artifact code '{}' from '{}' — renaming to: '{}'", artifactCode, file.getName(), renamedFile.getName());
+
         boolean renamed = file.renameTo(renamedFile);
         if (!renamed) {
             logger.error("Failed to rename '{}' to '{}' before reprocessing", file.getName(), renamedFile.getName());
             throw new IOException("Could not rename file: " + file.getAbsolutePath());
         }
-        logger.debug("Renamed successfully, reprocessing: {}", renamedFile.getName());
+        logger.debug("Renamed '{}' to '{}', reprocessing", file.getName(), renamedFile.getName());
+
         ProcessFile.process(renamedFile);
+        logger.info("Finished fixing trusty file (now reprocessed as: '{}')", renamedFile.getName());
     }
 
 }

Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,9 @@ public class ArtifactCodeImpl implements ArtifactCode {`
`25`	`25`	`if (TrustyUriUtils.isPotentialArtifactCode(artifactCode)) {`
`26`	`26`	`this.dataHash = TrustyUriUtils.getDataPart(artifactCode);`
`27`	`27`	`this.module = ModuleDirectory.getModule(TrustyUriUtils.getModuleId(artifactCode));`
	`28`	`+ logger.debug("Created ArtifactCodeImpl from code '{}': module='{}', dataHash='{}'", artifactCode, module.getModuleId(), dataHash);`
`28`	`29`	`} else {`
`29`		`- logger.error("Invalid artifact code: {}", artifactCode);`
	`30`	`+ logger.error("Invalid artifact code (failed format/length check): '{}'", artifactCode);`
`30`	`31`	`throw new IllegalArgumentException("Invalid artifact code: " + artifactCode);`
`31`	`32`	`}`
`32`	`33`	`}`
`@@ -39,19 +40,20 @@ public class ArtifactCodeImpl implements ArtifactCode {`
`39`	`40`	`*/`
`40`	`41`	`ArtifactCodeImpl(TrustyUriModule module, String dataHash) {`
`41`	`42`	`if (module == null) {`
`42`		`- logger.error("Module cannot be null");`
	`43`	`+ logger.error("Cannot create artifact code: module is null (dataHash='{}')", dataHash);`
`43`	`44`	`throw new IllegalArgumentException("Module cannot be null");`
`44`	`45`	`}`
`45`	`46`	`if (dataHash == null \|\| dataHash.isEmpty()) {`
`46`		`- logger.error("Data hash cannot be null or empty");`
	`47`	`+ logger.error("Cannot create artifact code: data hash is null or empty (module='{}')", module.getModuleId());`
`47`	`48`	`throw new IllegalArgumentException("Data hash cannot be null or empty");`
`48`	`49`	`}`
`49`	`50`	`if (module.getDataPartLength() != dataHash.length()) {`
`50`		`- logger.error("Data hash length does not match module requirements: expected {}, got {}", module.getDataPartLength(), dataHash.length());`
	`51`	`+ logger.error("Cannot create artifact code for module '{}': data hash '{}' has length {}, expected {}", module.getModuleId(), dataHash, dataHash.length(), module.getDataPartLength());`
`51`	`52`	`throw new IllegalArgumentException("Data hash length does not match module requirements: expected " + module.getDataPartLength() + ", got " + dataHash.length());`
`52`	`53`	`}`
`53`	`54`	`this.module = module;`
`54`	`55`	`this.dataHash = dataHash;`
	`56`	`+ logger.debug("Created ArtifactCodeImpl: module='{}', dataHash='{}'", module.getModuleId(), dataHash);`
`55`	`57`	`}`
`56`	`58`
`57`	`59`	`@Override`