Natuurlijk! Hier is een gids voor het implementeren van logging in je Ruby-toepassing met de Ruby Logger-klasse: 1. Logger-klasse gebruiken: De Ruby-klasse Logger maakt het eenvoudig om logs te genereren en te beheren. Je kunt een logger-object maken dat schrijft naar een bestand of naar de standaarduitvoer. ```ruby require 'logger' # Log naar een bestand logger = Logger.new('logfile.log') # Of log naar de console # logger = Logger.new(STDOUT) ``` 2. Logniveaus: Gebruik de juiste logniveaus om de ernst van de gebeurtenissen aan te geven: - DEBUG: Gedetailleerde informatie voor ontwikkeling en debugging. - INFO: Algemene informatieve berichten over de werking van de applicatie. - WARN: Waarschuwingen over mogelijke problemen die niet kritisch zijn. - ERROR: Fouten die het functioneren beïnvloeden, maar niet de hele applicatie stoppen. - FATAL: Kritieke fouten die de applicatie beëindigen. Voorbeeld: ```ruby logger.debug("Dit is een debugbericht") logger.info("Applicatie gestart") logger.warn("Onverwachte situatie, maar verder werken") logger.error("Fout opgetreden bij het verwerken van de gegevens") logger.fatal("Onherstelbare fout, applicatie wordt afgesloten") ``` 3. Effectief formatteren van logberichten: Je kunt een formatter instellen om de logberichten overzichtelijk te maken, bijvoorbeeld door tijdstempel, logniveau en bericht te tonen: ```ruby logger.formatter = proc do |severity, datetime, progname, msg| "#{datetime.strftime('%Y-%m-%d %H:%M:%S')} [#{severity}] #{msg}\n" end ``` 4. Plaatsen van logverklaringen: Plaats logverklaringen op belangrijke plaatsen in je code: - Aan het begin en einde van belangrijke methoden. - Bij exception handling om fouten vast te leggen. - Voor belangrijke gebeurtenissen zoals gebruikersinloggen, dataverwerking, externe API-aanroepen. Voorbeeld: ```ruby def process_data(data) logger.info("Start verwerking van data: #{data}") begin # Verwerking rescue => e logger.error("Fout tijdens verwerking: #{e.message}") ensure logger.info("Einde verwerking van data") end end ``` 5. Logs correct opslaan: - Zorg dat het logbestand een vaste locatie heeft en voldoende opslagcapaciteit. - Stel logrotatie in om te voorkomen dat het bestand te groot wordt: ```ruby logger = Logger.new('logfile.log', 'daily') # dagelijks roteren ``` - Voor productieomgevingen kun je gebruik maken van logrotate of vergelijkbare tools om logbestanden te beheren. Door deze stappen te volgen, kun je een effectief en goed georganiseerd logsysteem opzetten dat je helpt bij het monitoren en troubleshooten van je Ruby-toepassing.

Zeker! Hier is een uitgebreide handleiding voor het implementeren van logging in je Ruby-toepassing met de Logger-klasse. ## 1. Basisopstelling Logger ```ruby require 'logger' # Log naar bestand logger = Logger.new('app.log') # Of log naar STDOUT voor ontwikkeling logger = Logger.new(STDOUT) ``` ## 2. Logniveaus en hun gebruik Ruby Logger heeft 5 standaard niveaus (van laag naar hoog): ```ruby # DEBUG - Gedetailleerde informatie voor ontwikkelaars logger.debug("Gebruiker ingelogd: #{user_id}") # INFO - Algemene applicatiegebeurtenissen logger.info("Nieuwe bestelling geplaatst: #{order_id}") # WARN - Waarschuwingen, maar geen fouten logger.warn("Lage voorraad: product #{product_id}") # ERROR - Fouten die de operatie beïnvloeden logger.error("Betaling mislukt voor order: #{order_id}") # FATAL - Kritieke fouten die applicatie kunnen stoppen logger.fatal("Database verbinding verloren") ``` ## 3. Logniveau instellen ```ruby # Alleen WARN en hoger loggen logger.level = Logger::WARN # Of gebruik symbolen logger.level = :warn # Beschikbare niveaus: # :debug, :info, :warn, :error, :fatal ``` ## 4. Aangepaste formattering ```ruby logger.formatter = proc do |severity, datetime, progname, msg| "#{datetime.strftime('%Y-%m-%d %H:%M:%S')} [#{severity}] #{msg}\n" end # Geavanceerd voorbeeld met meer context logger.formatter = proc do |severity, datetime, progname, msg| timestamp = datetime.strftime('%Y-%m-%d %H:%M:%S.%L') "[#{timestamp}] #{severity} PID-#{Process.pid}: #{msg}\n" end ``` ## 5. Praktische implementatie in code ### In een Rails controller: ```ruby class OrdersController < ApplicationController def create begin logger.info("Order creatie gestart voor gebruiker: #{current_user.id}") @order = Order.new(order_params) if @order.save logger.info("Order succesvol aangemaakt: #{@order.id}") redirect_to @order else logger.warn("Order validatie gefaald: #{@order.errors.full_messages}") render :new end rescue => e logger.error("Order creatie mislukt: #{e.message}") logger.error(e.backtrace.join("\n")) flash[:error] = "Order kon niet worden aangemaakt" redirect_to root_path end end end ``` ### In een service class: ```ruby class PaymentService def initialize @logger = Logger.new('logs/payments.log') @logger.formatter = proc { |s, d, p, m| "#{d}: #{m}\n" } end def process_payment(amount, user_id) @logger.info("Betaling verwerken: €#{amount} voor gebruiker #{user_id}") if amount <= 0 @logger.error("Ongeldig bedrag: #{amount}") return false end # Betalingslogica... @logger.info("Betaling succesvol: #{payment_reference}") true rescue PaymentGatewayError => e @logger.error("Betalingsgateway fout: #{e.message}") false end end ``` ## 6. Logrotatie en bestandsbeheer ```ruby # Logrotatie - dagelijks nieuw bestand, maximaal 10 bestanden van 1MB logger = Logger.new('app.log', 10, 1_024_000) # Of wekelijkse rotatie logger = Logger.new('app.log', 'weekly') # Schoon oude logs op Logger.new('app.log', 5, 10_485_760) # 5 bestanden van ~10MB elk ``` ## 7. Geavanceerde configuratie ```ruby # Globale logger voor de applicatie class Application def self.logger @logger ||= setup_logger end def self.setup_logger logger = Logger.new('logs/application.log') logger.level = ENV['LOG_LEVEL'] || :info logger.formatter = proc do |severity, datetime, progname, msg| "#{datetime} [#{severity}] #{msg}\n" end logger end end # Gebruik in andere classes class UserService def create_user(user_data) Application.logger.info("Gebruiker aanmaken: #{user_data[:email]}") # ... implementatie end end ``` ## 8. Best practices voor logplaatsing ### Bij start/stoppen applicatie: ```ruby logger.info("Applicatie gestart in #{Rails.env} modus") logger.info("Applicatie afgesloten") ``` ### Bij belangrijke gebruikersacties: ```ruby logger.info("Gebruiker #{user_id} heeft account verwijderd") logger.warn("Verdachte login poging voor #{email}") ``` ### Bij externe API calls: ```ruby logger.info("API call naar payment service: #{endpoint}") logger.error("API timeout bij #{service_name}") ``` ### Bij database operaties: ```ruby logger.debug("SQL query: #{query}") logger.info("Database migratie voltooid: #{migration_name}") ``` ## 9. Omgevingsspecifieke configuratie ```ruby # config/environments/development.rb config.log_level = :debug config.logger = Logger.new(STDOUT) # config/environments/production.rb config.log_level = :info config.logger = Logger.new('log/production.log', 10, 10_485_760) ``` ## 10. Foutafhandeling met context ```ruby def process_data(data) logger.info("Data verwerking gestart: #{data.size} records") data.each_with_index do |record, index| begin process_record(record) logger.debug("Record #{index} verwerkt") rescue => e logger.error("Fout bij record #{index}: #{e.message}") logger.error("Record data: #{record.inspect}") # Doorgaan met volgende record end end logger.info("Data verwerking voltooid") end ``` Deze implementatie geeft je een robuust logsysteem dat fouten opspoort, belangrijke gebeurtenissen bijhoudt en je helpt bij het debuggen van problemen in je Ruby-toepassing.