Hier is een voorbeeld van een Ruby-script dat een aangepaste loggingframework opzet met de door u gevraagde functies. Het script maakt gebruik van de standaard `Logger`-klasse en voegt extra functionaliteit toe voor logrotatie en foutafhandeling. Daarnaast zorgt het voor duidelijke scheiding van verschillende logniveaus en een gestructureerde logweergave. ```ruby require 'logger' class AangepasteLogger attr_reader :logger def initialize(logbestand = 'logs/applicatie.log') # Zorg ervoor dat de logdirectory bestaat Dir.mkdir('logs') unless Dir.exist?('logs') # Initialiseer de logger met logrotatie op basis van bestandsgrootte (bijvoorbeeld 10MB) en aantal logbestanden (bijvoorbeeld 5) @logger = Logger.new(logbestand, 5, 10 * 1024 * 1024) @logger.level = Logger::DEBUG # Stel het standaard logniveau in op DEBUG voor volledige details # Definieer een formatter om het formaat aan te passen @logger.formatter = proc do |severity, datetime, progname, msg| "#{datetime.strftime('%Y-%m-%d')} - #{severity} - #{msg}\n" end end def debug(bericht) @logger.debug(bericht) end def info(bericht) @logger.info(bericht) end def waarschuwing(bericht) @logger.warn(bericht) end def fout(bericht) @logger.error(bericht) end # Mogelijkheid om een exception te loggen def log_exception(exception) fout("#{exception.class}: #{exception.message}\n#{exception.backtrace.join("\n")}") end end # Voorbeeldgebruik: log = AangepasteLogger.new begin log.debug("Dit is een debugbericht") log.info("Dit is een informatief bericht") log.warnings("Dit is een waarschuwing") # Simuleer een fout raise StandardError, "Er is iets misgegaan" rescue => e log.log_exception(e) end ``` ### Logrotatie De logrotatie wordt ingesteld via de parameters van `Logger.new`, bijvoorbeeld: ```ruby Logger.new(logbestand, 5, 10 * 1024 * 1024) ``` Hier betekent: - `5`: het aantal oude logbestanden dat wordt bewaard - `10 * 1024 * 1024`: maximale grootte van elk logbestand in bytes (hier 10MB) Wanneer de logfile deze grootte bereikt, wordt een nieuw logbestand gestart en worden oude bestanden gearchiveerd. ### Foutafhandeling - Fouten en uitzonderingen kunnen worden gelogd met de `log_exception`-methode, die het fouttype, bericht en traceback registreert. - Het gebruik van `begin...rescue` blokken in de code zorgt voor gecontroleerde foutafhandeling en logging. ### Onderhoudbaarheid en efficiëntie - Het gebruik van de ingebouwde `Logger` zorgt voor een robuust en efficiënt loggingmechanisme. - Door de formatter te definiëren, is de logoutput duidelijk en gestructureerd. - Logrotatie voorkomt dat logbestanden te groot worden, wat onderhoud vereenvoudigt. - Verschillende logniveaus maken het mogelijk om snel relevante informatie te vinden. Indien gewenst, kan het framework verder worden uitgebreid met functies zoals logniveau-instellingen via configuratiebestanden, asynchrone logging, of integratie met externe logmanagementsystemen.

Hier is een uitgebreid Ruby logging framework met de gevraagde functies: ```ruby # custom_logger.rb require 'fileutils' class CustomLogger LOG_LEVELS = { debug: 0, info: 1, warning: 2, error: 3 }.freeze def initialize(log_file = 'logs/application.log', level = :info, max_size = 1048576, backup_count = 5) @log_file = log_file @level = level @max_size = max_size @backup_count = backup_count # Zorg dat logs directory bestaat FileUtils.mkdir_p(File.dirname(@log_file)) # Open logbestand in append mode @file = File.open(@log_file, 'a') @file.sync = true # Zorg voor directe flushing end def debug(message) log(:debug, message) if should_log?(:debug) end def info(message) log(:info, message) if should_log?(:info) end def warning(message) log(:warning, message) if should_log?(:warning) end def error(message, exception = nil) log_message = message log_message += " - Exception: #{exception.class}: #{exception.message}\n#{exception.backtrace.join("\n")}" if exception log(:error, log_message) if should_log?(:error) end def close @file.close if @file && !@file.closed? end private def should_log?(message_level) LOG_LEVELS[message_level] >= LOG_LEVELS[@level] end def log(level, message) timestamp = Time.now.strftime("%Y-%m-%d") formatted_message = "#{timestamp} - #{level.to_s.upcase} - #{message}\n" begin check_rotation @file.write(formatted_message) @file.flush rescue IOError, SystemCallError => e # Fallback naar STDERR als logging faalt STDERR.puts "Logging failed: #{e.message}" STDERR.puts formatted_message end end def check_rotation return unless File.exist?(@log_file) if File.size(@log_file) >= @max_size rotate_logs end end def rotate_logs @file.close if @file && !@file.closed? # Verplaats huidige logs (@backup_count - 1).downto(1) do |i| current_file = "#{@log_file}.#{i}" next_file = "#{@log_file}.#{i + 1}" if File.exist?(current_file) File.rename(current_file, next_file) end end # Verplaats huidig logbestand naar .1 if File.exist?(@log_file) File.rename(@log_file, "#{@log_file}.1") end # Heropen het logbestand @file = File.open(@log_file, 'a') @file.sync = true end end # Gebruiksvoorbeeld: begin logger = CustomLogger.new('logs/application.log', :debug) logger.debug("Dit is een debug bericht") logger.info("Applicatie gestart") logger.warning("Waarschuwing: configuratie niet gevonden") logger.error("Ernstige fout opgetreden") # Voorbeeld met exception begin raise StandardError.new("Test exception") rescue => e logger.error("Er is een fout opgetreden", e) end logger.close rescue => e puts "Kon logger niet initialiseren: #{e.message}" end ``` ## Uitleg van de implementatie: ### **Log Rotatie:** - **`check_rotation`**: Controleert of het logbestand de maximale grootte heeft bereikt - **`rotate_logs`**: Implementeert logrotatie door bestanden te hernoemen: - `application.log` → `application.log.1` - `application.log.1` → `application.log.2` - etc. - **Configuratie**: `max_size` (standaard 1MB) en `backup_count` (standaard 5) ### **Foutafhandeling:** - **Exception logging**: De `error` methode accepteert een optionele exception - **Fallback mechanisme**: Als schrijven naar het bestand faalt, wordt uitgevallen naar STDERR - **Bestandsoperaties**: Gebruikt `begin/rescue` blokken voor robuuste bestandsoperaties ### **Efficiëntie en Onderhoud:** - **Log levels**: Duidelijke hiërarchie met `LOG_LEVELS` hash - **Formattering**: Gestandaardiseerd formaat `JJJJ-MM-DD - NIVEAU - BERICHT` - **Automatische directory creatie**: `FileUtils.mkdir_p` zorgt voor logs directory - **Buffering**: `@file.sync = true` voor directe flushing ### **Gebruik:** ```ruby # Initialisatie met aangepaste instellingen logger = CustomLogger.new('logs/app.log', :info, 5 * 1024 * 1024, 10) # Verschillende log levels logger.debug("Alleen voor ontwikkeling") logger.info("Normale operatie") logger.warning("Onverwachte situatie") logger.error("Kritieke fout", exception_object) ``` Dit framework biedt een robuuste, efficiënte en onderhoudbare logging oplossing met alle gevraagde functies.