Monitoring as an instance of behaviour in Erlang

Abstract

Runtime Monitoring consists of regular observation and gathering of information during runtime which is used to measure correctness. There are various distinct technologies which utilise monitoring; however all these monitors have some commonalities that can be identified and used to create a design pattern. These patterns are generic solutions to a frequently occurring problem, and are also language independent. I produced the required design pattern by extracting the common structure found between every monitor. I therefore identified a design pattern for concurrent monitors, which all the monitors can adopt. A number of benefits are introduced when making use of a design pattern, which are; introduction of reusability, better maintainability, better standard approach, and also a simplified approach to implement a monitor since it creates a modular implementation rather than a monolithic one. I implemented this design pattern in the Erlang programming language as a behaviour. Behaviours are a form of abstract classes for Erlang which are used to design templates and also offer some code implementation. This means that an Erlang behaviour is designed as an instantiation of the monitor design pattern. To further facilitate the implementation of monitors, I instantiated this design pattern for the context of a runtime verification tool, called ELARVA. Given some high level specifications, this tool generates monitoring code automatically. By instantiating the design pattern in the ELARVA context, the generated monitoring code can be disentangled from the ELARVA tool and hence acquire the full benefits of the design pattern. It means that the monitoring code can be modified without editing the script and recompiling the compiler. This is possible, since the behaviour provides an interface to construct and instrument concurrent monitors, and therefore the generated code is now independent of the ELARVA tool and can be modified by the programmer.