Show HN: Decorate Java stack traces with source code snippets

This is pretty awesome! This got me curious if I can do this in C# so I took a quick stab at it. It's not actually updating the original stack trace but it's kind of cool. Might be worth exploring further :)

    static void Main()
    {
        try
        {
            throw new DivideByZeroException("Boom!");
        }
        catch (Exception ex)
        {
            var trace = new StackTrace(ex, true);
            var frame = trace.GetFrame(0);

            var targetFilename = frame.GetFileName();
            var targetLineNumber = frame.GetFileLineNumber();

            Console.WriteLine($"Exception occurred at {targetFilename}, line {targetLineNumber}");

            if (File.Exists(targetFilename))
            {
                var source = File.ReadAllLines(targetFilename);
                var startIndex = Math.Max(0, targetLineNumber - 3);
                var endIndex = Math.Min(source.Length - 1, targetLineNumber + 1);

                for (var i = startIndex; i <= endIndex; i++)
                {
                    var lineNumber = i + 1;
                    Console.WriteLine($"{(lineNumber == targetLineNumber ? $">> {lineNumber}" : $"   {lineNumber}")}{source[i]}");
                }
            }
        }
    }

I did this a while back for Python:

https://GitHub.com/qix-/better-exceptions

Reminds me of power assertions in Groovy - one of my favorite features!

Thanks for publishing. From the title was expecting that we'd get the code snippet related to the code itself, rather than the junit where the code failed.

But I guess for such feature to be possible you'd have to pack the source code inside the jar itself.

Loving it! Building a Maven Surefire plug-in to do this was on my list of potential side projects for quite a while, so cool that someone finally did this. Even better as a JUnit extension. Congrats on the release, can't wait to give it a try!.

One big "off-label" use of stack traces for me is to determine the caller method of the current method. I use it in a lightly customised log function to also log the name of the method that has emitted the log.

FYI: for the gradle dependencies section on the read me, both junit4 and junit5 say junit5.

This look pretty useful, thanks.

Great work - I like this a lot

Awesome !! Good to see this

Very cool work!

Some unsolicited opinion: One potential code pet peeve i always have is that the overloads being used in java serves no purpose, but makes the code super confusing to read without using an IDE.

For example, https://github.com/laech/java-stacksrc/blob/main/core/src/ma... , which is code to decorate the stacktrace element, calls the function `decorate`. However, there's several overloads, all named decorate! It is certainly a better naming convention to call it `decorateElement` imho.