Hier is een voorbeeld van een Python-script dat logniveaus dynamisch instelt op basis van gebruikersinvoer en logs naar zowel de console als een bestand stuurt. Daarnaast leg ik uit hoe je de loggingconfiguratie structureert om meerdere outputs te ondersteunen en hoe je logrotatie beheert. **Python-script:** ```python import logging from logging import handlers # Vraag de gebruiker om het logniveau log_level_input = input("Voer het logniveau in (DEBUG, INFO, WARNING, ERROR, CRITICAL): ").upper() # Map gebruikersinvoer naar logging niveaus log_levels = { 'DEBUG': logging.DEBUG, 'INFO': logging.INFO, 'WARNING': logging.WARNING, 'ERROR': logging.ERROR, 'CRITICAL': logging.CRITICAL } # Controleer of de invoer geldig is if log_level_input not in log_levels: print("Ongeldig logniveau, standaard op INFO gezet.") log_level = logging.INFO else: log_level = log_levels[log_level_input] # Configureer de logger logger = logging.getLogger('MijnLogger') logger.setLevel(log_level) # Formatter voor de logs formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # Handler voor console console_handler = logging.StreamHandler() console_handler.setFormatter(formatter) # Handler voor bestand met logrotatie (bv. dagelijks of bij grootte) file_handler = handlers.TimedRotatingFileHandler('logfile.log', when='midnight', backupCount=7) file_handler.setFormatter(formatter) # Voeg handlers toe aan logger logger.addHandler(console_handler) logger.addHandler(file_handler) # Voorbeeldgebruik logger.debug("Dit is een DEBUG-bericht.") logger.info("Dit is een INFO-bericht.") logger.warning("Dit is een WARNING-bericht.") logger.error("Dit is een ERROR-bericht.") logger.critical("Dit is een CRITICAL-bericht.") ``` --- **Uitleg over de loggingconfiguratie:** - **Meerdere outputs ondersteunen:** Door verschillende handlers toe te voegen aan de logger, zoals `StreamHandler` voor console-uitvoer en `TimedRotatingFileHandler` voor logbestanden, kunnen logs gelijktijdig op meerdere plaatsen worden weergegeven. Elke handler kan een eigen formatter, niveau en outputmedium hebben. - **Logrotatie beheren:** Met `TimedRotatingFileHandler` kun je logs automatisch roteren op basis van tijd (bijvoorbeeld dagelijks bij 'midnight') of op basis van grootte (met `RotatingFileHandler`). In het voorbeeld gebruik ik `TimedRotatingFileHandler` die elke dag om middernacht een nieuw logbestand maakt en tot 7 oude logs bewaart (`backupCount=7`). **Samenvatting:** Door gebruik te maken van meerdere handlers en een logrotatie-handler, kun je flexibel logs beheren en voorkomen dat logbestanden te groot worden. Het dynamisch instellen van het logniveau op basis van gebruikersinvoer maakt je logging configuratie interactief en aanpasbaar.

Hier is een Python-script dat dynamische logging implementeert met meerdere outputs en logrotatie: ```python import logging import logging.handlers import sys def setup_logging(log_level): """ Stelt logging in met console en bestandsoutput met rotatie """ # Log niveau omzetten van string naar logging constante level = getattr(logging, log_level.upper(), logging.INFO) # Hoofdlogger aanmaken logger = logging.getLogger() logger.setLevel(level) # Formatter voor consistente logberichten formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S' ) # Console handler console_handler = logging.StreamHandler(sys.stdout) console_handler.setLevel(level) console_handler.setFormatter(formatter) # Bestand handler met rotatie (max 5MB per bestand, 3 backup bestanden) file_handler = logging.handlers.RotatingFileHandler( 'application.log', maxBytes=5*1024*1024, # 5MB backupCount=3, encoding='utf-8' ) file_handler.setLevel(level) file_handler.setFormatter(formatter) # Handlers toevoegen aan logger logger.addHandler(console_handler) logger.addHandler(file_handler) return logger def main(): # Gebruikersinvoer simuleren (DEBUG) user_input = "DEBUG" # Logging instellen logger = setup_logging(user_input) # Testberichten op verschillende niveaus logger.debug("Dit is een DEBUG bericht - gedetailleerde informatie") logger.info("Dit is een INFO bericht - algemene informatie") logger.warning("Dit is een WARNING bericht - waarschuwing") logger.error("Dit is een ERROR bericht - foutmelding") logger.critical("Dit is een CRITICAL bericht - kritieke fout") print(f"\nLogging is ingesteld op niveau: {user_input}") print("Logs worden weggeschreven naar 'application.log' en getoond in de console") if __name__ == "__main__": main() ``` ## Uitleg van de loggingstructuur: ### 1. Multi-output configuratie: - **Console Handler**: Toont logs in de terminal/console - **File Handler**: Schrijft logs naar een bestand met UTF-8 encoding - Beide handlers gebruiken dezelfde formatter voor consistentie ### 2. Logrotatie beheer: - **RotatingFileHandler** zorgt voor automatische rotatie - `maxBytes=5*1024*1024`: Maximaal 5MB per logbestand - `backupCount=3`: Bewaar maximaal 3 oude logbestanden - Wanneer het huidige bestand 5MB bereikt, wordt het hernoemd en een nieuw bestand gestart ### 3. Dynamisch niveau instellen: - `getattr(logging, log_level.upper())` zet gebruikersinvoer om naar logging constanten - Werkt met: DEBUG, INFO, WARNING, ERROR, CRITICAL - Fallback naar INFO bij ongeldige invoer ### 4. Formatter opbouw: - Tijdstip, loggernaam, niveau en bericht - Aanpasbaar naar behoefte ## Gebruik: ```python # Voor dynamische gebruikersinvoer: user_level = input("Voer log niveau in (DEBUG/INFO/WARNING/ERROR/CRITICAL): ") logger = setup_logging(user_level) ``` Het script creëert logbestanden zoals: - `application.log` (huidig) - `application.log.1` (oudste backup) - `application.log.2` - `application.log.3` (meest recente backup)