Logging and handling Java errors - Latest

For information on the Java API, see the "laeJavaApi" Zip file which you will find in the following location: <Data360Analyze installation directory>/docs/lae

The Node interface defines an accessor to a Logger object. The Logger provides utility methods for writing to the log with varying LogLevels , as follows, in order of severity:

• DEBUG
• INFO
• WARN
• ERROR

The different log levels can be used by calling the logger().log(LogLevel level, …) method. Alternatively, the logger().debug, logger().info, logger().warn and logger().error methods can be used.

There are a large number of variants for these methods, taking different parameters. See the "laeJavaApi" Zip file (see <Data360Analyze installation directory>/docs/lae) for the full list of method variants on the Logger class.

The severity of the log level with which the message is logged, in comparison to the LogLevel property on the Java node determine whether or not the message is actually written to the log.

These log levels are outlined in the following table:

The methods inherited by the Node that the node developer is expected to write (setup, processAll and cleanup) only declare to throw NodeFailedExceptions. When a NodeFailedException is thrown from the body of one of these methods, then will assume that the node has written all of the required information to the log, so will not automatically log any error information.

Therefore, it is the responsibility of the node developer to ensure that when any exception is thrown from within one of these methods, one of the following occurs:

• The exception is caught, handled, and processing can continue.
• The exception is caught, logged, the node status is set to fail (via calling the fail() method) and a NodeFailedException is thrown or the method returns normally.
• The exception is caught, logged, the node status set to an appropriate non-failure state based on the exception and a NodeFailedException is thrown or the method returns normally.

The following example shows the correct mechanism for logging errors and failing the node:

try

{

//get the required properties

m_outputAsFloat = properties().getBoolean( propertyBase() + ".outputFloat");

m_inputColumnName = properties().getString( propertyBase() + ".inputColumnName");

m_outputColumnName = properties().getString( propertyBase() + ".outputColumnName");

}

catch (PropertyException ex)

{

logger().error(ex, Logger.CHAIN_END, "Error reading node properties.");

throw fail();

}

If a PropertyException occurs during this attempt, the code first obtains the Logger using the logger() accessor and writes an error to the log. The Logger.CHAIN_END argument simply tells the log that it shouldn’t expect any more error messages related to this error, and to end the error chain. This can be left off the call to error without ill-effects.

Following this, the code will set the state of the node to failed, using the fail() method defined on the Node interface. The fail method returns a NodeFailedException which is then thrown by the code within the setup method.