About Us Products Articles News Contact Support

Programming Distributed Systems with YAMI4

8.3.2 Logging

There is no provision for internal event logging in the Python library.

The Ada and C++ libraries offer the possibility to report internal events to user-provided callback implementations of a dedicated interface - the interface is called event_callback in the C++ library and appropriate Ada definitions are grouped in the YAMI.Event_Notification_Handlers package.

The following events are reported via these interfaces:

agent was created,
agent was closed,
listener was added,
listener was removed,
new connection was created,
connection was closed,
there was an I/O error on the given connection,
object was registered,
object was unregistered,
outgoing message was sent,
incoming message was received

In addition to these interfaces, default implementations of activity monitors are provided that implement these interfaces. The activity monitors can be also accessed as regular remote objects and as such can be used as simple sources of activity statistics for both in-process and remote inspection.

The Java and .NET libraries offer the possibility to report internal events with various verbosity.

In Java, the LogCallback interface provides a foundation for the user-provided callback implementations and LogCallback.LogLevel enumerations allow to select the required level of verbosity. The callback implementation can be provided to the agent's constructor and is fixed for the agent's lifetime.

The following is an example of simple user-defined log callback and its use with the agent constructor:

    private static class MyLogSink implements LogCallback {
        @Override
        public void log(LogLevel level, String msg) {
            System.out.println(level.toString() + ": " + msg);
        }
    }

    // ...

    agent = new Agent(options,
        new MyLogSink(), LogCallback.LogLevel.MEDIUM);

Three levels of event logging are defined in the LogCallback.LogLevel enumeration type:

LOW, which reports on the following events:

agent was created,
agent was closed,
listener was added,
listener was removed,
channel was opened,
channel was closed

MEDIUM, which reports all events of the LOW level and adds the following events:

object was registered,
object was unregistered,
message was sent,
message was received,
message was dispatched to the message handler,
reply was sent,
reply was received,
rejection was sent,
rejection was received

HIGH, which reports all events of the LOW and MEDIUM levels and adds the following:

frame was sent,
frame was received

Note:

The log callback can be used as a hook for integration with external logging frameworks like log4j. The YAMI4 library, as such, has no dependency on any external logging mechanism.

In .NET programs log events can be propagated to the user code by means of a delegate, which can be installed with one of the agent's constructor. The LogEventArgs class, together with its nested LogLevel enumeration type, define the protocol for passing log information to the user. Further delegates can be added to the agent's logging system at run-time with the help of the publicly available Log event. The granularity and meaning of logging levels is exactly as described above for the Java library.