The incident with no cause in the logs

import java.io.*;

/**
 * Root cause: two independent instances of "the real exception was thrown away".
 *
 * 1. download() closes the connection in a finally block. When close() throws
 *    while the IOException from fetch() is already propagating, the new
 *    exception does not wrap the old one — it REPLACES it. The IOException
 *    naming the malformed row is destroyed at that moment. Nothing logs it,
 *    nothing chains it, it is simply gone.
 *
 *    That is why the only stack trace in the logs belongs to the connection
 *    pool: it is the last exception standing, and its stack shows the pool
 *    because that is where it was created. The pool was never the problem — it
 *    was the messenger, and it overwrote the message.
 *
 *    try-with-resources fixes exactly this. The body's exception stays primary
 *    and the close() failure is attached via addSuppressed(), so both survive.
 *    This is the correctness reason to use it. Closing the resource for you is
 *    the convenience reason.
 *
 * 2. reconcile() catches and rethrows without passing the cause. Even with
 *    fix #1 in place, that second bug would still discard everything below it.
 *    Both had to be fixed; fixing either one alone leaves on-call blind.
 *
 * Why manual retries sometimes worked: the pool only double-releases under
 * concurrent load. Run the job by hand off-peak and close() succeeds, so the
 * real IOException survives and the job fails with a readable error — or the
 * partner has since re-sent a valid file and it passes outright. Either way the
 * evidence pointed away from the actual defect.
 *
 * What the import layer should throw: an unchecked, domain-specific exception —
 * ReconciliationFailed — carrying the partner, the file and the cause. Unchecked
 * because no caller up this stack can recover from a malformed partner file;
 * the only sane responses are alert and retry, and forcing every intermediate
 * layer to declare `throws` buys nothing. Domain-specific because the scheduler
 * should not need to know that this particular partner is reached over SFTP.
 * This is the same reasoning Spring applies when it wraps SQLException into
 * unchecked DataAccessException.
 */
public class Solution {

    static final class PooledConnection implements Closeable {
        private final String partner;

        PooledConnection(String partner) {
            this.partner = partner;
        }

        String fetch(String file) throws IOException {
            throw new IOException("malformed row 4128 in " + file + " from " + partner);
        }

        @Override
        public void close() {
            throw new IllegalStateException("connection already released");
        }
    }

    /** Unchecked and domain-specific, carrying context as fields. */
    static final class ReconciliationFailed extends RuntimeException {
        private final String partner;
        private final String file;

        ReconciliationFailed(String partner, String file, Throwable cause) {
            super("reconciliation failed for " + partner + " file " + file, cause);
            this.partner = partner;
            this.file = file;
        }

        String partner() {
            return partner;
        }

        String file() {
            return file;
        }
    }

    /**
     * FIX 1: try-with-resources. The IOException from fetch() stays primary and
     * the close() failure rides along as a suppressed exception.
     */
    static String download(String partner, String file) throws IOException {
        try (PooledConnection conn = new PooledConnection(partner)) {
            return conn.fetch(file);
        }
    }

    /** FIX 2: wrap WITH the cause, and add the context on-call needs. */
    static void reconcile(String partner, String file) {
        try {
            download(partner, file);
        } catch (IOException e) {
            throw new ReconciliationFailed(partner, file, e);
        }
    }

    public static void main(String[] args) {
        String partner = "acme-bank";
        String file = "settlements-2026-08-24.csv";

        Throwable surfaced = null;
        try {
            reconcile(partner, file);
        } catch (Throwable t) {
            surfaced = t;
        }

        System.out.println("what on-call sees");
        System.out.println("  exception   : " + surfaced.getClass().getSimpleName());
        System.out.println("  message     : " + surfaced.getMessage());

        Throwable root = surfaced;
        while (root.getCause() != null) root = root.getCause();
        System.out.println("  root cause  : " + root.getClass().getSimpleName()
            + ": " + root.getMessage());
        System.out.println("  suppressed  : " + root.getSuppressed().length);
        for (Throwable s : root.getSuppressed()) {
            System.out.println("    " + s.getClass().getSimpleName() + ": " + s.getMessage());
        }

        String all = describe(surfaced);
        boolean namesRealCause = all.contains("malformed row");
        boolean keepsCloseFailure = all.contains("already released");

        System.out.println();
        System.out.println("mentions the real cause (malformed row) : " + namesRealCause);
        System.out.println("close failure still reachable           : " + keepsCloseFailure);
        System.out.println(namesRealCause && keepsCloseFailure ? "PASS" : "FAIL");
    }

    static String describe(Throwable t) {
        StringBuilder sb = new StringBuilder();
        for (Throwable c = t; c != null; c = c.getCause()) {
            sb.append(c.getClass().getSimpleName()).append(": ").append(c.getMessage()).append('\n');
            for (Throwable s : c.getSuppressed()) {
                sb.append("  suppressed ").append(s.getClass().getSimpleName())
                  .append(": ").append(s.getMessage()).append('\n');
            }
        }
        return sb.toString();
    }
}