@injae-kim nim, I've implemented recording the exception in the thrownExceptionCounters when it's not null.
Did I understand the intention correctly?
Please let me know if I've misunderstood anything.
Thank you. 🙇

I have a question about this code.
Why is this::reportException called repeatedly at regular intervals?
I'm wondering why we don't call this::reportException only once when the report method is invoked.
Thank you. 🙇

@injae-kim nim, I have a question 🙇
When referring to this test, even though it's the same IllegalArgumentException, it's being recognized as a new key because they are different objects.
Is this the direction we want? I thought that even if they are different objects, they should be recognized as the same key if they have the same type. 😄
Thank you~!

Let's wait maintainer's comment here~! 🙇

If stack traces and exception messages differ, the same exception type should be corrected separately. Exceptions.traceText(cause) can be used as keys instead of instances themselves.

    // akka
    implementation libs.akka.actor.typed.v213

private static class ThrowableEntry {
  LongAdder adder;
  ServiceRequestContext ctx;
}

private Map<Throwable, ThrowableEntry> thrownExceptions;

oh instead of import Pair on akka, can we add some class like ThrowableEntry?
then we don't need to import akka 😄

We don't want to add an additional dependency for this. Should we use Map.Entry or a custom class as suggested by @injae-kim instead?

We don't want to add an additional dependency for this. Should we use Map.Entry or a custom class as suggested by @injae-kim instead?

This method is called by multiple threads for which HashMap can' be used.

What do you think of a dedicated class to collect exceptions and encapsulate the logic?

final class ExceptionStats {
    private Map<String, ExceptionContext> exceptions = ...;
    // A lock is required to thread-safely update `exceptions` field
    private final ReentrantShortLock lock = ...

    void record(ServiceRequestContext ctx, Throwable cause) {
        lock.lock();
        try {
            exceptions.compute(Exceptions.traceText(cause), (key, value) -> {
                ...
                value.increase();
                ...
            });
        } finally {
            lock.unlock();
        }
    }

    Collection<ExceptionContext> dump() {
        lock.lock();
        try {
            final Map<String, ExceptionContext> oldExceptions = exceptions;
            // Allocate a new map
            exceptions = new HashMap<>();
            return oldExceptions.values();
        } finally {
            lock.unlock();
        }
    }

    private static class ExceptionContext {
        private final Throwable exception;
        // Capture the first context when the exception is raised for better debugging
        private final ServiceRequestContext ctx;
        private long counter = 1;
        ...
    }
}

When reportException() is invoked, we may dump the counted exceptions and log all of them.

private void reportException() {
    for (exceptionContext: exceptionStats.dump()) {
          logger.warn("Observed {} exception(s) that ...", exceptionContext.count(), ...);
    }
}

Introduce ExceptionStats class looks nice to me too here!