Log4E inserts logger statements at certain method entries. You can specify the behaviour for each entry differently. The entries are separated in different tabs.

Tab Method Start

It defines the very beginning of the method. The logger statement is inserted there. If method is a constructor and does a constructor invocation (i.e. this(), super()) the logger statement is inserted right behind the invocation.

Options:

• Skip logging for this position
  If checked logger statements are not inserted at the beginning of method.
• Skip in Constructor
  If Log4E is invoked for the whole class, it leaves out constructor methods
• Skip methods with empty body
  If checked logger statements are not inserted in empty methods.
• Skip getter
  If checked logger statements are not inserted in getter methods.
  The plugin identifies any method that looks like that:
  

  public String anyMethodName() {
  	return "mystring";
  }

  The method in the example doesn't even have a prefix "get" but has all qualities of a getter method.

• Skip setter
  If checked logger statements are not inserted in setter methods.
  The plugin identifies any method that looks like that:
  

  public void anyMethodName(String mystring) {
  	this.mystring = mystring;
  }

  The method in the example doesn't even have a prefix "set" but has all qualities of a setter method.

• Use position log statements instead of level statements
  Use the alternative position statements. They are defined in Log4E > Templates > Position Statements
• Choose level
  Defines the level of logger. The recommended level for this position is DEBUG.
• Insert info about current method
  if disabled, current method infos are not provided
• Log with parameter types of method
  Argument types of method
  Example:

  logger.debug("myMethod(String) - start");

• Log with parameter names of method
  Argument names of method
  Example:

  logger.debug("myMethod(arg1) - start");

• Log with parameter values of method
  Argument values of method
  Example:

  logger.debug("myMethod(" + arg1 + ") - start");

• Logger message
  Your message after method name
  Example:

  logger.debug("myMethod(String) - start");

  As a result the logger statements are automatically inserted like in that example:

  public String myMethod(String arg1) {
  	if (logger.isDebugEnabled()) {
  		logger.debug("myMethod(String arg1 = " + arg1 + ") - start");
  	}
  	
  	//Your code....
  }

Tab Method Exit

It defines the exit point of a method. That could be a return statement or the end of the method.
Therefore a logger statement is inserted before every return statement and at the end of method.

The settings are the same as at start position except these:

Options:

• Move invocation in return statement in front of logger
• Include return value
  Inserts the return value in logger statement

Example:

Before:

public String myMethod(String arg1) {
	//Your code....
	return toString();
}

After:

public String myMethod(String arg1) {

	//Your code....
	String returnString = toString();
	logger.debug("myMethod() - end - return value = " + returnString);
	return returnString;
}

Tab Catch Block

It defines the position in a try - catch block. Normally a logger with ERROR level is inserted here providing the given exception.

The settings are the same as at start position. Some additional options are available:

• Skip empty catch block
  If checked, logger statements are not inserted in empty catch blocks. If unchecked, the options "Level for empty catch block" and "Message in empty catch block (${message})" will be used instead.
• Level for empty catch block
  Choose a level that should be used in empty catch blocks. This can be different from "Choose level". Default: "Log4j Warn/JDK14 Warning"
• Message in empty catch block (${message})
  Choose a message that should be used in empty catch blocks. This can be different from "Logger message". Default: "exception ignored"
• Log all variables available
  If checked all variables available in the scope of the current catch block will be logged.
  

Tab Other

It defines all other positions than "Method Start", "Method Exit" or "Catch Block".
This occurs when System out's are replaced at other positions or when log statements are modified at other positions or if you use the "Insert Log Statement At This Position..." task.

The settings are reduced to the needed information.