La prise de mesure en AOP avec JAMon

Voici un article qui propose une solution pour effectuer des mesures de performance en s'appuyant sur l'AOP (Aspect Oriented Programmation). L'exemple suivant propose d'utiliser l'implémentation AspectJ couplée avec l'outil Open Source JAMon.

J'ai assisté, il y a peu, à une excellente présentation de l'AOP et de AspectJ plus particulièrement. J'ai tout de suite été séduit et j'ai donc cherché des applications pratiques pour ce genre de technologie.
Le cas d'école pour apprendre l'AOP que l'on trouve régulièrement est l'exemple du logging.

public aspect LoggerAspect {
	pointcut log() : call(* *.methodToLog(..));

	before() : log() {
		System.out.println("Avant l'exécution de"+thisJoinPoint.toShortString()) ;
	}

	after() : log() {
		System.out.println("Après l'exécution de"+thisJoinPoint.toShortString()) ;
	}
}

Cet aspect affiche un message avant et après l'appel de la méthode.

Je vous propose ici de modifier cet exemple pour effectuer des mesures de performance dans une application.
Pour cela nous pouvons utiliser JAMon qui permet de positionner simplement des prises de mesure et de les consulter au travers d'une application web fournie. Dans JAMon, on utilise des Monitor auquel on associe un nom logique.

Pour notre prise de mesure, nous voulons savoir combien de temps on passe dans telle ou telle partie de code. A la différence de l'exemple du login, le pointcut que nous allons définir va utiliser le mot-clé execution plutot que call pour se positionner au plus près du code exécuté.

La définition du _poincut_ sera d'autant plus simple si le code que l'on doit monitorer a été contraint par des règles de nommage ou si les éléments du code utilise ou hérite d'un framework.

Exemple :

pointcut monitor() : execution(* *.*Service.*(..)) ; // Correspond à toutes les méthodes des classes qui finissent par Service
pointcut monitor() : execution(* *.GenericService+.*(..)) ; // Correspond à toutes les méthodes des classes qui héritent de la classe GenericService
pointcut monitor() : execution(* *.services.*.add*(..)) ; // Correspond à toutes les méthodes qui commencent par add des classes qui sont dans le package *.services.*

Ensuite, Il faut définir l'advice. Nous voulons savoir combien de temps prend l'exécution des méthodes correspondant au pointcut. Nous utiliserons donc le mot-clé arround() qui permet d'effectuer des pré\- et post-traitements.

Puisque nous allons positionner ces prises de mesure avec de l'AOP, nous utiliserons thisJointPoint.toShortString() (qui donne le nom court du pointcut) comme nom pour le Monitor JAMon que nous positionnerons.

Voici l'exemple complet :

public aspect PerfMonitor {
	pointcut monitor() : execution(* *.ClassToMonitor.methodToMonitor(..)) ;

	Object arround() : monitor() {
		Monitor monitor = MonitorFactory.start(thisJoinPoint.toShortString());
		Object returnedObject = proceed();
		monitor.stop();
		// Si on veut avoir une trace de la mesure dans les logs
		// LogFactory.getLog(getClass()).debug(monitor.toString()) ;
		return returnedObject;
	}
}

Une fois, notre aspect définit, nous allons pouvoir voir ce que donne notre prise de mesure.

La distribution de JAMon contient une application web qui permet de visualiser les statistiques des différents Monitor positionnés dans le code.

Pour que cela fonctionne simplement, il suffit de déposer le fichier jamon.jar dans le répertoire de librairie partagée (ex: common/lib sous Tomcat) afin que les classes de JAMon soient chargées par le « system class loader ». Ensuite, déployer l'application web jamon.war comme n'importe quelle application.

Une fois votre application démarrée, vous pouvez accéder à la page http://webserver/jamon/jamonadmin.jsp pour voir les statistiques produites par le monitoring de votre code.

Voici un exemple du rendu de cette page :

Remarque : JAMon fournit d'autres possibilités de prise de mesure :

• le ServletFilter JAMon qui va mesurer le temps de chargement de chaque page pour avoir un aperçu global des performances de l'application.
• le JAMonDriver ou la JAMonDataSource qui encapsule le vrai driver JDBC pour mesurer les accès à la base de données.

Ce genre d'outil est surtout en mode « diagnostic » pour trouver et optimiser les traitements coûteux plutôt que pour effectuer de véritables tests de performance sur une application.
L'avantage de le combiner avec de l'AOP, c'est de permettre de « monitorer » des traitements dont nous n'avons pas le code source.

L'outil Glassbox qui permet de faire des prises mesures automatiquement dans une application se base justement sur l'AOP pour positionner ses messures.