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]}");
}
}
}
}
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.
If I understand your use case, most loggers (like Logback) have the possiblity to automatically include the name of the method that called the log-statement.
Logback even supports including the call chain in the output, so you could include the parent method, grand parent method etc. This probably uses reflection, so it could have a negative impact for applications that need a high performance.
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.
