CODEWITHSUNDEEP
javadebugging
tb189
tb189

Reputation: 2012

Java - Line by line 'debug report'

The program I'm building seems to freeze at some points on the user's system. When I test the very same steps, I see no problem. Even though Java is supposed to be a platform-independent VM, my guess is it has to do with the systems we're using (I'm on linux, the user on Mac), maybe something with file access.

I cannot access the user's system, and the user has no idea what debugging means. In order to test where the problem is, I was thinking of writing the program's progress to a file, and having him send me the file when there's a problem. Therefore my question:

Is there some kind of library which allows writing the line by line execution of a program to a file? Ideally, the values of certain variables would also be included.

edit: I'm familiar with Logger, but (like one answer says), that would require writing a lot of log statements. Is there some way to do this automatic? Maybe line by line is overkill, but something like log each method entry/exit would definitely work.

Thanks a lot!

Upvotes: 1

Views: 282

Answers (3)

Michel Mansour
Michel Mansour

Reputation: 48

This might be a good use case for aspect-oriented programming. Specifically, the AspectJ library for Java might suit your needs (there are others, but this is the one I'm most familiar with). You could define a logging aspect that would automatically insert method entry/exit log messages into the methods you wish to trace, without having to modify the code for those methods. The aspect can be included or excluded as you wish whenever you build the application (eg, include it just for this user until you resolve the issue).

Something like the following might be a good start:

aspect LogAllMethods {
  Log log = new Log(); // pseudocode -- replace with whatever logging mechanism you like

  before(): call(public * com.mycompany.*.*(..)) {
    log.log("Entered method: " + thisJoinPoint);
  }

  after(): call(public * com.mycomapny.*.*(..)) { 
    log.log("Leaving method: " + thisJoinPoint);
  }
}

This basically says that, before and after any public method call in the package com.mycompany, log the entry/exit and the name of the method (thisJoinPoint is a special variable in AspectJ that refers to the point in the program's execution that the aspect is being applied to). The AspectJ documentation has some nice tutorials and examples of defining aspects and how they can be used, as well as instructions on how to introduce aspects into your application.

This might be overkill for your situation and underutilization of AspectJ, but it should allow you to do some fine-grained debugging without having to add logging calls to every method in your code.

Upvotes: 3

Mansoor Siddiqui
Mansoor Siddiqui

Reputation: 21703

It sounds like what you want is logging in your application. See the Wikipedia article for Java Logging Frameworks for details.

Some of the more common logging frameworks, all mentioned in the aforementioned article, are:

Upvotes: 0

Mark Peters
Mark Peters

Reputation: 81154

Typically the debug information you want would be included in a log file. Logging frameworks like Java's built in Logging API allow you to configure what severity of messages to produce when the program is run. In other words, you could have it normally report severe errors only, but enable debug output selectively when you need more information.

However, logging frameworks normally require you, the programmer, to explicitly tell it what to log. It doesn't simply log everything (that would be a lot of data too!).

Upvotes: 0

Related Questions