clean logging system

synergine2/core.py

 from synergine2.base import BaseObject
 from synergine2.config import Config
 from synergine2.cycle import CycleManager
-from synergine2.log import SynergineLogger
+from synergine2.log import get_logger
 from synergine2.simulation import Simulation
 from synergine2.terminals import TerminalManager
 from synergine2.terminals import Terminal
     def __init__(
         self,
         config: Config,
-        logger: SynergineLogger,
         simulation: Simulation,
         cycle_manager: CycleManager,
         terminal_manager: TerminalManager=None,
         cycles_per_seconds: float=1.0,
     ):
         self.config = config
-        self.logger = logger
+        self.logger = get_logger('Core', config)
         self.simulation = simulation
         self.cycle_manager = cycle_manager
-        self.terminal_manager = terminal_manager or TerminalManager(config, logger, [])
+        self.terminal_manager = terminal_manager or TerminalManager(config, [])
         self._loop_delta = 1./cycles_per_seconds
         self._current_cycle_start_time = None
         self._continue = True

synergine2/cycle.py

 from synergine2.base import BaseObject
 from synergine2.config import Config
 from synergine2.exceptions import SynergineException
-from synergine2.log import SynergineLogger
+from synergine2.log import get_logger
 from synergine2.processing import ProcessManager
 from synergine2.share import shared
 from synergine2.simulation import Subject
     def __init__(
             self,
             config: Config,
-            logger: SynergineLogger,
             simulation: Simulation,
             process_manager: ProcessManager=None,
     ):
         # TODO: reproduire le mechanisme d'index de behaviour/etc pour simulation
         self.config = config
-        self.logger = logger
+        self.logger = get_logger('Cycle', config)
         self.simulation = simulation
         self.current_cycle = -1
         self.first_cycle = True

synergine2/log.py

 import sys
 import typing
 
+from synergine2.config import Config
+
 STREAM_HANDLER_TAG = '__STREAM_HANDLER__'
 
 
         self.handlers.append(logging.StreamHandler(sys.stdout))
 
 
-def get_default_logger(name: str='synergine', level: int=logging.ERROR) -> SynergineLogger:
+def get_default_logger(
+    name: str='synergine',
+    level: int=logging.ERROR,
+) -> SynergineLogger:
     """
     WARNING: Set global logging Logger class to SynergineLogger
     """
     logger = logging.getLogger(name)
     logger = typing.cast(SynergineLogger, logger)
     handler = logging.StreamHandler(sys.stdout)
-    formatter = logging.Formatter('%(asctime)s|%(name)s|%(process)d|%(levelname)s: %(message)s')
+    formatter = logging.Formatter(
+        '%(asctime)s|%(name)s|%(process)d|%(levelname)s: %(message)s',
+    )
     handler.setFormatter(formatter)
     logger.addHandler(handler)
     logger.setLevel(level)
 
     return logger
+
+
+def get_logger(name: str, config: Config) -> SynergineLogger:
+    global_logging_level = config.resolve('global.logging_level', 'ERROR')
+    logger_level_str = config.resolve('global.logging.{}.level', global_logging_level)
+    logger_level = logging.getLevelName(logger_level_str)
+    return get_default_logger('synergine-{}'.format(name), logger_level)

synergine2/terminals.py

 from synergine2.exceptions import SynergineException
 from synergine2.share import shared
 from synergine2.config import Config
-from synergine2.log import SynergineLogger
+from synergine2.log import get_logger
 from synergine2.simulation import Subject
 from synergine2.simulation import Event
 
     def __init__(
         self,
         config: Config,
-        logger: SynergineLogger,
         asynchronous: bool=True,
     ):
         self.config = config
-        self.logger = logger
+        self.logger = get_logger(self.__class__.__name__, config)
         self._input_queue = None
         self._output_queue = None
         self._stop_required = False
     def __init__(
         self,
         config: Config,
-        logger: SynergineLogger,
         terminals: [Terminal]
     ):
         self.config = config
-        self.logger = logger
+        self.logger = get_logger('TerminalManager', config)
         self.terminals = terminals
         self.outputs_queues = {}
         self.inputs_queues = {}

synergine2_cocos2d/gui.py

 from cocos.audio.pygame import mixer
 from cocos.layer import ScrollableLayer
 from synergine2.config import Config
-from synergine2.log import SynergineLogger
+from synergine2.log import get_logger
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
 from synergine2_cocos2d.actor import Actor
     def __init__(
         self,
         config: Config,
-        logger: SynergineLogger,
         layer_manager: LayerManager,
         grid_manager: GridManager,
         worldview,
         super().__init__()
 
         self.config = config
-        self.logger = logger
+        self.logger = get_logger('EditLayer', config)
         self.layer_manager = layer_manager
         self.grid_manager = grid_manager
 
     def __init__(
             self,
             config: Config,
-            logger: SynergineLogger,
             terminal: Terminal,
             physics: Physics,
             read_queue_interval: float= 1/60.0,
     ):
         self.config = config
-        self.logger = logger
+        self.logger = get_logger('Gui', config)
         self.physics = physics
         self._read_queue_interval = read_queue_interval
         self.terminal = terminal
 
         self.interaction_manager = InteractionManager(
             config=self.config,
-            logger=self.logger,
             terminal=self.terminal,
         )
         self.layer_manager = self.layer_manager_class(
             self.config,
-            self.logger,
             middleware=self.get_layer_middleware(),
             interaction_manager=self.interaction_manager,
             gui=self,
     def __init__(
         self,
         config: Config,
-        logger: SynergineLogger,
         terminal: Terminal,
         physics: Physics,
         read_queue_interval: float = 1 / 60.0,
         self.map_dir_path = map_dir_path
         super(TMXGui, self).__init__(
             config,
-            logger,
             terminal,
             physics=physics,
             read_queue_interval=read_queue_interval,
     def get_layer_middleware(self) -> MapMiddleware:
         return TMXMiddleware(
             self.config,
-            self.logger,
             self.map_dir_path,
         )
 

synergine2_cocos2d/interaction.py

 import typing
 
 from synergine2.config import Config
-from synergine2.log import SynergineLogger
+from synergine2.log import get_logger
 from synergine2.simulation import SimulationBehaviour
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
     def __init__(
         self,
         config: Config,
-        logger: SynergineLogger,
         terminal: Terminal,
     ) -> None:
         self.config = config
-        self.logger = logger
+        self.logger = get_logger(InteractionManager, config)
         self.terminal = terminal
         self.interactions = []
 
     ) -> None:
         self.interactions.append(interaction_class(
             self.config,
-            self.logger,
             terminal=self.terminal,
             layer_manager=layer_manager,
         ))
     def __init__(
         self,
         config: Config,
-        logger: SynergineLogger,
         terminal: Terminal,
         layer_manager: LayerManager,
     ) -> None:
         self.config = config
-        self.logger = logger
+        self.logger = get_logger(self.__class__.__name__, config)
         self.terminal = terminal
         self.layer_manager = layer_manager
 

synergine2_cocos2d/layer.py

 import cocos
 
 from synergine2.config import Config
-from synergine2.log import SynergineLogger
+from synergine2.log import SynergineLogger, get_logger
 from synergine2_cocos2d.middleware import MapMiddleware
 
 if False:
     def __init__(
         self,
         config: Config,
-        logger: SynergineLogger,
         middleware: MapMiddleware,
         interaction_manager: 'InteractionManager',
         gui: 'Gui',
     ) -> None:
         self.config = config
-        self.logger = logger
+        self.logger = get_logger('LayerManager', config)
         self.middleware = middleware
         self.interaction_manager = interaction_manager
         self.gui = gui
         )
         self.edit_layer = self.edit_layer_class(
             self.config,
-            self.logger,
             self,
             self.grid_manager,
             self.main_layer,

synergine2_cocos2d/middleware.py

 
 import cocos
 from synergine2.config import Config
-from synergine2.log import SynergineLogger
+from synergine2.log import get_logger
 
 
 class MapMiddleware(object):
     def __init__(
         self,
         config: Config,
-        logger: SynergineLogger,
         map_dir_path: str,
     ) -> None:
         self.config = config
-        self.logger = logger
+        self.logger = get_logger(self.__class__.__name__, config)
         self.map_dir_path = map_dir_path
         self.tmx = None
 

tests/test_cycle.py

     def test_subjects_cycle(self):
         shared.reset()
         config = Config({'core': {'use_x_cores': 2}})
-        logger = SynergineLogger(name='test')
 
         simulation = Simulation(config)
         subjects = MySubjects(simulation=simulation)
 
         cycle_manager = CycleManager(
             config=config,
-            logger=logger,
             simulation=simulation,
         )
 
     def test_new_subject(self):
         shared.reset()
         config = Config({'core': {'use_x_cores': 1}})
-        logger = SynergineLogger(name='test')
 
         simulation = Simulation(config)
         subjects = MySubjects(simulation=simulation)
 
         cycle_manager = CycleManager(
             config=config,
-            logger=logger,
             simulation=simulation,
         )
 
     def test_simulation_events(self):
         shared.reset()
         config = Config({'core': {'use_x_cores': 2}})
-        logger = SynergineLogger(name='test')
 
         simulation = MySimulation(config)
-
         subjects = MySubjects(simulation=simulation)
         simulation.subjects = subjects
 
         cycle_manager = CycleManager(
             config=config,
-            logger=logger,
             simulation=simulation,
         )
 

tests/test_simulation.py

 
 from synergine2.config import Config
 from synergine2.cycle import CycleManager
-from synergine2.log import SynergineLogger
 from synergine2.processing import ProcessManager
 from synergine2.share import shared
 from synergine2.simulation import Simulation
 from freezegun import freeze_time
 
 config = Config()
-logger = SynergineLogger('test')
 
 
 class MySubjectMechanism(SubjectMechanism):
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )
 
         cycle_manager = CycleManager(
             config,
-            logger,
             simulation=simulation,
             process_manager=do_nothing_process_manager,
         )

tests/test_terminals.py

 from synergine2.config import Config
 from synergine2.core import Core
 from synergine2.cycle import CycleManager
-from synergine2.log import SynergineLogger
 from synergine2.share import shared
 from synergine2.simulation import Event
 from synergine2.simulation import Simulation
     def test_terminal_communications(self):
         terminals_manager = TerminalManager(
             Config(),
-            SynergineLogger('test'),
             terminals=[
-                MultiplyTerminal(Config(), SynergineLogger('test')),
+                MultiplyTerminal(Config()),
             ]
         )
         terminals_manager.start()
     def test_terminals_communications(self):
         terminals_manager = TerminalManager(
             Config(),
-            SynergineLogger('test'),
             terminals=[
-                MultiplyTerminal(Config(), SynergineLogger('test')),
-                DivideTerminal(Config(), SynergineLogger('test')),
+                MultiplyTerminal(Config()),
+                DivideTerminal(Config()),
             ]
         )
         terminals_manager.start()
 
         terminals_manager = TerminalManager(
             Config(),
-            SynergineLogger('test'),
-            terminals=[ListenEverythingTerminal(Config(), SynergineLogger('test'))]
+            terminals=[ListenEverythingTerminal(Config())]
         )
         terminals_manager.start()
         terminals_manager.send(ValueTerminalPackage(value=42))
 
         terminals_manager = TerminalManager(
             Config(),
-            SynergineLogger('test'),
-            terminals=[ListenAnEventTerminal(Config(), SynergineLogger('test'))]
+            terminals=[ListenAnEventTerminal(Config())]
         )
         terminals_manager.start()
         terminals_manager.send(ValueTerminalPackage(value=42))
     def test_terminal_as_main_process(self):
         shared.reset()
         config = Config()
-        logger = SynergineLogger('test')
         simulation = Simulation(config)
         simulation.subjects = Subjects(simulation=simulation)
         cycle_manager = CycleManager(
             config=config,
-            logger=logger,
             simulation=simulation,
         )
 
                 global terminal_pid
                 terminal_pid = os.getpid()
 
-        terminal = MyMainTerminal(config, logger)
+        terminal = MyMainTerminal(config)
 
         class MyCore(Core):
             def _end_cycle(self):
 
         core = MyCore(
             config=config,
-            logger=logger,
             simulation=simulation,
             cycle_manager=cycle_manager,
             terminal_manager=TerminalManager(
                 config=config,
-                logger=logger,
                 terminals=[terminal],
             ),
         )