[sre] Enable specific logging for the kernel modules.

see #1029

Signed-off-by: Stéphane Galland <galland@arakhne.org>

sre/io.janusproject/io.janusproject.network/src/main/sarl/io/sarl/sre/network/boot/internal/Messages.sarl

@@ -41,6 +41,7 @@ final class Messages extends NLS {
 
 	public static var NetworkModuleProvider_0 : String
 	public static var HazelcastLogListener_0 : String
+	public static var HazelcastLogListener_1 : String
 
 	private new {
 	}

sre/io.janusproject/io.janusproject.network/src/main/sarl/io/sarl/sre/network/boot/internal/NetworkModule.sarl

@@ -149,16 +149,16 @@ class HazelcastLogListener implements LogListener {
 	/** 
 	 * SRE Kernel logger
 	 */
-	var kernelLogger : Logger;
+	var logger : Logger
 
 	@Inject
 	new(logger : LoggingService) {
-		kernelLogger = logger.kernelLogger
+		this.logger = logger.getKernelLogger(Messages::HazelcastLogListener_1)
 	}
 
 
 	def log(logEvent : LogEvent) {		
-		this.kernelLogger.log(logEvent.logRecord.level,
+		this.logger.log(logEvent.logRecord.level,
 			MessageFormat::format(Messages::HazelcastLogListener_0, logEvent.member, logEvent.logRecord.message))
 	}
 

sre/io.janusproject/io.janusproject.network/src/main/sarl/io/sarl/sre/network/boot/internal/messages.properties

@@ -1,2 +1,3 @@
 NetworkModuleProvider_0=The module for enabling network communication between SRE kernels.
-HazelcastLogListener_0=From: {0}::{1}
+HazelcastLogListener_0=From: {0}::{1}
+HazelcastLogListener_1=Hazelcast node

sre/io.janusproject/io.janusproject.network/src/main/sarl/io/sarl/sre/network/services/HazelcastContextService.sarl

@@ -34,11 +34,10 @@ import io.sarl.sre.services.context.Context
 import io.sarl.sre.services.context.ContextFactory
 import io.sarl.sre.services.context.MemoryBasedContextService
 import io.sarl.sre.services.logging.LoggingService
+import java.text.MessageFormat
 import java.util.UUID
-import java.util.logging.Level
 import java.util.logging.Logger
 import javax.inject.Inject
-import java.text.MessageFormat
 
 /** Implementation of a context-space service that is connected to remote SRE with the Hazelcast framework.
  *
@@ -66,44 +65,40 @@ class HazelcastContextService extends MemoryBasedContextService {
 	 */
 	var defaultSpacesListenerID : UUID
 
-	/** 
-	 * SRE Kernel logger
-	 */
-	var kernelLogger : Logger;
-
 	@Inject
-	new(sreConfig : SreConfig, @KernelScope rootContext : Context, injector : Injector, factory : ContextFactory,
-		iHazelcastInstance : HazelcastInstance, logger : LoggingService) {
-		super(rootContext, injector, factory);
+	new(sreConfig : SreConfig, @KernelScope rootContext : Context, logger : LoggingService, injector : Injector,
+		factory : ContextFactory, hazelcastInstance : HazelcastInstance) {
+		super(rootContext, logger, injector, factory);
 
-		hazelcastInstance = iHazelcastInstance;
-		kernelLogger = logger.kernelLogger
+		this.hazelcastInstance = hazelcastInstance
 
 		/*kernelLogger.log(Level::INFO, "Creating HazelcastContextService")
 		kernelLogger.log(Level::INFO, "RootID from BootCOnfig: " + sreConfig.boot.rootContextID)
 		kernelLogger.log(Level::INFO, "RootSpaceID from BootCOnfig: " + sreConfig.boot.rootSpaceID)
 		kernelLogger.log(Level::INFO, "RootID from rootContext: " + rootContext.ID)
 		kernelLogger.log(Level::INFO, "RootSpaceID from rootContext: " + rootContext.defaultSpace.spaceID.ID)*/
-		kernelLogger.log(Level::INFO, Messages::HazelcastContextService_0)
-		defaultSpaces = this.hazelcastInstance.getMap(sreConfig.boot.rootContextID.toString());
+		this.logger.info[Messages::HazelcastContextService_0]
+		this.defaultSpaces = this.hazelcastInstance.getMap(sreConfig.boot.rootContextID.toString());
 
 		// Can't access to that rootContext.defaultSpace 
 		// registering root context, the root context is created differently than other contexts using a call to the ContextFactory directly
-		kernelLogger.log(Level::INFO, Messages::HazelcastContextService_1)
+		this.logger.info[Messages::HazelcastContextService_1]
 		this.defaultSpaces.putIfAbsent(sreConfig.boot.rootContextID, sreConfig.boot.rootSpaceID);
 
-		kernelLogger.log(Level::INFO, Messages::HazelcastContextService_2)
+		this.logger.info[Messages::HazelcastContextService_2]
 
 		var defaultSpacesListener : EntryListener<UUID, UUID> = new DefaultSpacesMapListener(this)
-		defaultSpacesListenerID = defaultSpaces.addEntryListener(defaultSpacesListener, true)
-		kernelLogger.log(Level::INFO, Messages::HazelcastContextService_3)
+		this.defaultSpacesListenerID = this.defaultSpaces.addEntryListener(defaultSpacesListener, true)
+		this.logger.info[Messages::HazelcastContextService_3]
+	}
 
+	protected override createLogger(loggingService : LoggingService) : Logger {
+		loggingService.getKernelLogger(Messages::HazelcastContextService_9)
 	}
 
 	protected def newContextInstance(contextID : UUID, defaultSpaceID : UUID, owner : Agent) : Context {
-		kernelLogger.log(Level::INFO, MessageFormat::format(Messages::HazelcastContextService_4, contextID, defaultSpaceID))
+		this.logger.info[MessageFormat::format(Messages::HazelcastContextService_4, contextID, defaultSpaceID)]
 		this.defaultSpaces.putIfAbsent(contextID, defaultSpaceID);
-
 		return super.newContextInstance(contextID, defaultSpaceID, owner)
 	}
 
@@ -118,14 +113,14 @@ class HazelcastContextService extends MemoryBasedContextService {
 	}
 
 	protected def ensureDefaultSpaceDefinition(contextID : UUID, defaultSpaceID : UUID, owner : Agent) {
-		kernelLogger.log(Level::INFO, MessageFormat::format(Messages::HazelcastContextService_5, defaultSpaceID, contextID))
+		this.logger.info[MessageFormat::format(Messages::HazelcastContextService_5, defaultSpaceID, contextID)]
 
 		if (!this.contextInternalStructure.containsKey(contextID)) {
 			// Assuming the first request we got, is the one corresponding to the default space
 			super.createContext(contextID, defaultSpaceID, owner);
 		} else {
 			if (getContext(contextID).defaultSpace.spaceID.ID != defaultSpaceID) {
-				kernelLogger.log(Level::SEVERE, MessageFormat::format(Messages::HazelcastContextService_6, defaultSpaceID, contextID))
+				this.logger.severe[MessageFormat::format(Messages::HazelcastContextService_6, defaultSpaceID, contextID)]
 			}
 		}
 	}
@@ -135,11 +130,11 @@ class HazelcastContextService extends MemoryBasedContextService {
 
 			if (getContext(contextID).defaultSpace.spaceID.ID === defaultSpaceID) {
 
-				kernelLogger.log(Level::INFO, MessageFormat::format(Messages::HazelcastContextService_7, defaultSpaceID, contextID))
+				this.logger.info[MessageFormat::format(Messages::HazelcastContextService_7, defaultSpaceID, contextID)]
 				super.removeContext(contextID)
 
 			} else {
-				kernelLogger.log(Level::SEVERE, MessageFormat::format(Messages::HazelcastContextService_8, defaultSpaceID, contextID))
+				this.logger.severe[MessageFormat::format(Messages::HazelcastContextService_8, defaultSpaceID, contextID)]
 			}
 
 		}
@@ -148,8 +143,8 @@ class HazelcastContextService extends MemoryBasedContextService {
 	override onStop {
 		super.onStop
 		// TODO check if it is really necessary to clean this distributed map of Contexts, because it will impact other kernels staying active on the network
-		defaultSpaces.clear
-		defaultSpaces.removeEntryListener(defaultSpacesListenerID)
+		this.defaultSpaces.clear
+		this.defaultSpaces.removeEntryListener(this.defaultSpacesListenerID)
 	}
 
 	/** Listener on Hazelcast's shared map events.
@@ -164,20 +159,20 @@ class HazelcastContextService extends MemoryBasedContextService {
 		var hazelcastContextService : HazelcastContextService
 
 
-		new(iHazelcastContextService : HazelcastContextService) {
-			hazelcastContextService = iHazelcastContextService
+		new(hazelcastContextService : HazelcastContextService) {
+			this.hazelcastContextService = hazelcastContextService
 		}
 
 		def entryAdded(^event : EntryEvent<UUID, UUID>) {
-			hazelcastContextService.ensureDefaultSpaceDefinition(^event.key, ^event.value, null)
+			this.hazelcastContextService.ensureDefaultSpaceDefinition(^event.key, ^event.value, null)
 		}
 
 		def entryUpdated(^event : EntryEvent<UUID, UUID>) {
 			//
 		}
 
 		def entryRemoved(^event : EntryEvent<UUID, UUID>) {
-			hazelcastContextService.removeDefaultSpaceDefinition(^event.key, ^event.value)
+			this.hazelcastContextService.removeDefaultSpaceDefinition(^event.key, ^event.value)
 		}
 
 		def entryEvicted(^event : EntryEvent<UUID, UUID>) {

sre/io.janusproject/io.janusproject.network/src/main/sarl/io/sarl/sre/network/services/HazelcastEventTransportService.sarl

@@ -93,7 +93,7 @@ class HazelcastEventTransportService implements EventTransportService {
 	/** 
 	 * SRE Kernel logger
 	 */
-	var kernelLogger : Logger;
+	var kernelLogger : Logger
 
 	public static val HAZELCAST_SARL_TOPICS_NAME_SET = "io.sarl.topics.distributedset"
 
@@ -105,7 +105,7 @@ class HazelcastEventTransportService implements EventTransportService {
 		contextService = icontextService
 		hazelcastInstance = iHazelcastInstance
 
-		kernelLogger = logger.kernelLogger
+		kernelLogger = logger.getKernelLogger(Messages::HazelcastEventTransportService_1)
 
 		topicListenerIDs = new ConcurrentHashMap<String, UUID>();
 		this.availableTopicsName = this.hazelcastInstance.getSet(HAZELCAST_SARL_TOPICS_NAME_SET);

sre/io.janusproject/io.janusproject.network/src/main/sarl/io/sarl/sre/network/services/HazelcastSpaceRepository.sarl

@@ -42,8 +42,8 @@ import io.sarl.sre.spaces.SreSpaceSpecificationFactory
 import java.text.MessageFormat
 import java.util.UUID
 import java.util.logging.Level
-import java.util.logging.Logger
 import javax.inject.Inject
+import java.util.logging.Logger
 
 /** Implementation of a space repository that is connected to remote SRE with Hazelcast framework.
  *
@@ -82,23 +82,18 @@ class HazelcastSpaceRepository extends LocalSpaceRepository {
 	 */
 	var availableTopicsName : ISet<String>
 
-	/** 
-	 * SRE Kernel logger
-	 */
-	var kernelLogger : Logger;
-
 	public static val HAZELCAST_SPACE_ID_MAP_NAME = "io.sarl.network.distributedSpaceIDMapName"
 
 	@Inject
-	new(injector : Injector, executor : ExecutorService, config : SreConfig,
+	new(injector : Injector, executor : ExecutorService,
+		loggingService : LoggingService, config : SreConfig,
 		specificationFactory : SreSpaceSpecificationFactory,
 		listenerCollection : SmartListenerCollection<?>,
-		icontextService : ContextService, iHazelcastInstance : HazelcastInstance, logger : LoggingService) {
-		super(injector, executor, config, specificationFactory, listenerCollection)
+		icontextService : ContextService, iHazelcastInstance : HazelcastInstance) {
+		super(injector, executor, loggingService, config, specificationFactory, listenerCollection)
 		contextService = icontextService
 		hazelcastInstance = iHazelcastInstance
-		kernelLogger = logger.kernelLogger
-		kernelLogger.log(Level::INFO, Messages::HazelcastSpaceRepository_0)
+		this.logger.log(Level::INFO, Messages::HazelcastSpaceRepository_0)
 		availableTopicsName = this.hazelcastInstance.getSet(
 			HazelcastEventTransportService.HAZELCAST_SARL_TOPICS_NAME_SET);
 		spaceIDs = this.hazelcastInstance.getMap(HAZELCAST_SPACE_ID_MAP_NAME);
@@ -136,8 +131,11 @@ class HazelcastSpaceRepository extends LocalSpaceRepository {
 
 		}
 		spaceIDsListernerID = spaceIDs.addEntryListener(spaceIDsListerner, true)
-		kernelLogger.log(Level::INFO, Messages::HazelcastSpaceRepository_1)
+		this.logger.log(Level::INFO, Messages::HazelcastSpaceRepository_1)
+	}
 
+	protected override createLogger(loggingService : LoggingService) : Logger {
+		loggingService.getKernelLogger(Messages::HazelcastSpaceRepository_5)
 	}
 
 	protected override createSpaceFirstInstance(spec : Class<? extends SpaceSpecification<S>>, spaceID : SpaceID,
@@ -146,12 +144,12 @@ class HazelcastSpaceRepository extends LocalSpaceRepository {
 		// checking that the enclosing context of this new space already exists locally before creating the space
 		var localContext = contextService.getContext(spaceID.contextID)
 		if (localContext === null) {
-			kernelLogger.log(Level::SEVERE, Messages::HazelcastSpaceRepository_2)
+			this.logger.log(Level::SEVERE, Messages::HazelcastSpaceRepository_2)
 		}
 		this.spaceIDs.putIfAbsent(spaceID, creationParams);
 		// FIXME Extract topic name creation in a dedicated function
 		var topicName : String = HazelcastEventTransportService.getTopicNameFromSpaceID(spaceID)
-		kernelLogger.log(Level::INFO, MessageFormat::format(Messages::HazelcastSpaceRepository_3, spaceID, topicName))
+		this.logger.log(Level::INFO, MessageFormat::format(Messages::HazelcastSpaceRepository_3, spaceID, topicName))
 		this.availableTopicsName.add(topicName)
 
 		return super.createSpaceFirstInstance(spec, spaceID, creationParams);
@@ -176,7 +174,7 @@ class HazelcastSpaceRepository extends LocalSpaceRepository {
 		// FIXME Extract topic name creation in a dedicated function
 		var topicName : String = HazelcastEventTransportService.HAZELCAST_SARL_TOPICS_ROOTWILCARD + SpaceName.SCHEME +
 			"." + id.contextID + "." + id.ID
-		kernelLogger.log(Level::INFO, MessageFormat::format(Messages::HazelcastSpaceRepository_4, topicName))
+		this.logger.log(Level::INFO, MessageFormat::format(Messages::HazelcastSpaceRepository_4, topicName))
 		this.availableTopicsName.remove(topicName)
 		super.removeSpaceIfEmpty(id.ID)
 	}

sre/io.janusproject/io.janusproject.network/src/main/sarl/io/sarl/sre/network/services/Messages.sarl

@@ -44,7 +44,9 @@ final class Messages extends NLS {
 	public static var HazelcastSpaceRepository_2 : String
 	public static var HazelcastSpaceRepository_3 : String
 	public static var HazelcastSpaceRepository_4 : String
+	public static var HazelcastSpaceRepository_5 : String
 	public static var HazelcastEventTransportService_0 : String
+	public static var HazelcastEventTransportService_1 : String
 	public static var TopicNameListener_0 : String
 	public static var TopicNameListener_1 : String
 	public static var TopicNameListener_2 : String
@@ -59,6 +61,7 @@ final class Messages extends NLS {
 	public static var HazelcastContextService_6 : String
 	public static var HazelcastContextService_7 : String
 	public static var HazelcastContextService_8 : String
+	public static var HazelcastContextService_9 : String
 
 	private new {
 	}

sre/io.janusproject/io.janusproject.network/src/main/sarl/io/sarl/sre/network/services/messages.properties

@@ -1,20 +1,23 @@
 HazelcastSpaceRepository_0=Creating the Hazelcast space repository
 HazelcastSpaceRepository_1=End of creating the Hazelcast space repository
-HazelcastSpaceRepository_2=HazelcastSpaceRepository: Creating a space but the corresponding enclosing context did not exist locally
-HazelcastSpaceRepository_3=HazelcastSpaceRepository: New space created {0}, adding a new topic named {1}
-HazelcastSpaceRepository_4=HazelcastSpaceRepository: Space removed, removing the topic named {0}
-HazelcastEventTransportService_0=HazelcastEventTransportService: About to publish a network message (type={0}) on space {1} in the context {2} using the topic named {3}
-TopicNameListener_0=HazelcastEventTransportService: New space topic created with the following name {0}
-TopicNameListener_1=HazelcastEventTransportService: Adding listener for the following space {0}
-TopicNameListener_2=HazelcastEventTransportService: Existing space topic removed with the following name {0}
-TopicMessageListener_0=HazelcastEventTransportService: Receiving distant Space message from the space {0}  of the Context {1} and dispatching this event locally
-TopicMessageListener_1=HazelcastEventTransportService: Receiving distant message from the space {0}  of the Context {1} but this context does not exist locally
-HazelcastContextService_0=HazelcastContextService: About to get map
-HazelcastContextService_1=HazelcastContextService: Registering Root Context on distributed map
-HazelcastContextService_2=HazelcastContextService: About to create listener
-HazelcastContextService_3=HazelcastContextService: End of Creating the Hazelcast context service
-HazelcastContextService_4=HazelcastContextService: Adding new Context {0} and its default space {1}
-HazelcastContextService_5=HazelcastContextService: Creating local space {0} of the Context {1} following a network request
-HazelcastContextService_6=HazelcastContextService: Trying to create a local space {0} considered as the default space of the Context {1} following a network request, but is is not
-HazelcastContextService_7=HazelcastContextService: Removing local space {0} of the Context {1} following a network request
-HazelcastContextService_8=HazelcastContextService: Trying to remove a local space {0} considered as the default space of the Context {1} following a network request, but is is not
+HazelcastSpaceRepository_2=Creating a space but the corresponding enclosing context did not exist locally
+HazelcastSpaceRepository_3=New space created {0}, adding a new topic named {1}
+HazelcastSpaceRepository_4=Space removed, removing the topic named {0}
+HazelcastSpaceRepository_5=Hazelcast space repository
+HazelcastEventTransportService_0=About to publish a network message (type={0}) on space {1} in the context {2} using the topic named {3}
+HazelcastEventTransportService_1=Hazelcast transport service
+TopicNameListener_0=New space topic created with the following name {0}
+TopicNameListener_1=Adding listener for the following space {0}
+TopicNameListener_2=Existing space topic removed with the following name {0}
+TopicMessageListener_0=Receiving distant Space message from the space {0}  of the Context {1} and dispatching this event locally
+TopicMessageListener_1=Receiving distant message from the space {0}  of the Context {1} but this context does not exist locally
+HazelcastContextService_0=About to get map
+HazelcastContextService_1=Registering Root Context on distributed map
+HazelcastContextService_2=About to create listener
+HazelcastContextService_3=End of Creating the Hazelcast context service
+HazelcastContextService_4=Adding new Context {0} and its default space {1}
+HazelcastContextService_5=Creating local space {0} of the Context {1} following a network request
+HazelcastContextService_6=Trying to create a local space {0} considered as the default space of the Context {1} following a network request, but is is not
+HazelcastContextService_7=Removing local space {0} of the Context {1} following a network request
+HazelcastContextService_8=Trying to remove a local space {0} considered as the default space of the Context {1} following a network request, but is is not
+HazelcastContextService_9=Hazelcast context service

sre/io.janusproject/io.janusproject.plugin/src/main/sarl/io/sarl/sre/Kernel.sarl

@@ -123,7 +123,7 @@ class Kernel {
 
 		// Start the services NOW to ensure that the default context and space
 		// of the SRE agent are catched by the modules;
-		this.serviceManager.startServices(getLogger)
+		this.serviceManager.startServices(getLogger(null))
 	}
 
 	/** Create an instance of the kernel event listener.
@@ -152,11 +152,11 @@ class Kernel {
 	 * <p>This function replies the logger of the logging service. If this service is down,
 	 * {@code null} is replied.
 	 * 
+	 * @param moduleName the name of the module for which the logger is replied.
 	 * @return the logger of the kernel.
-	 * @see #getShutdownSafeLogger()
 	 */
-	def getLogger : Logger {
-		this.loggingService.kernelLogger
+	def getLogger(moduleName : String) : Logger {
+		this.loggingService.getKernelLogger(moduleName)
 	}
 
 	/** 
@@ -221,7 +221,7 @@ class Kernel {
 	@PrivateAPI
 	package def executeKernelStopWhenNoAgentAlive(internalStop : boolean) {
 		if (!this.isStopping.getAndSet(true)) {
-			val logger = getLogger
+			val logger = getLogger(null)
 			logger.info [if(internalStop) Messages.Kernel_0 else Messages.Kernel_3]
 			val ss = this.spawnService
 			val sl = this.stopListener
@@ -353,7 +353,7 @@ class Kernel {
 		override uncaughtException(thread : Thread, exception : Throwable) {
 			assert thread !== null;
 			assert exception !== null;
-			val logger = this.kernel.get.logger
+			val logger = this.kernel.get.getLogger(null)
 			if (logger !== null && logger.isLoggable(Level::SEVERE)) {
 				val record = new LogRecord(Level::SEVERE, exception.localizedMessage)
 				record.thrown = exception

sre/io.janusproject/io.janusproject.plugin/src/main/sarl/io/sarl/sre/boot/internal/internal/PlatformEventEmitterModule.sarl

@@ -57,7 +57,7 @@ class PlatformEventEmitterModule extends AbstractModule {
 	@KernelScope
 	@Singleton
 	static def provideExternalContextMemberListener(logging : Provider<LoggingService>) : ExternalContextMemberListener {
-		new ContextMemberEventEmitter(logging.get.kernelLogger)
+		new ContextMemberEventEmitter(logging.get.getKernelLogger(null))
 	}
 
 	@Provides
@@ -85,7 +85,7 @@ class PlatformEventEmitterModule extends AbstractModule {
 	@KernelScope
 	@Singleton
 	static def provideLifecycleServiceListener(logging : Provider<LoggingService>) : LifecycleServiceListener {
-		new AgentEventEmitter(logging.get.kernelLogger)
+		new AgentEventEmitter(logging.get.getKernelLogger(null))
 	}
 
 }