Hier is een voorbeeld van een Ruby-script dat een in-memory caching-mechanisme implementeert voor het API-eindpunt https://api.example.com/users. Het script gebruikt een eenvoudige hash om cache-opslag bij te houden, behandelt cache-verval en geeft logs voor cache-hits en misses. ```ruby require 'net/http' require 'json' require 'logger' require 'time' # Logger instellen logger = Logger.new(STDOUT) logger.level = Logger::INFO # Cache-structuur # Elke cache-entry bevat: data, timestamp @cache = {} CACHE_TTL = 300 # cache vervalt na 300 seconden (5 minuten) def fetch_users url = URI.parse('https://api.example.com/users') response = Net::HTTP.get_response(url) if response.is_a?(Net::HTTPSuccess) JSON.parse(response.body) else raise "API-fout: #{response.code} #{response.message}" end end def get_cached_data(cache_key) entry = @cache[cache_key] if entry age = Time.now - entry[:timestamp] if age < CACHE_TTL return entry[:data] else # cache is verlopen @cache.delete(cache_key) end end nil end def set_cache(cache_key, data) @cache[cache_key] = { data: data, timestamp: Time.now } end def main(logger) cache_key = 'users' # Check cache cached_data = get_cached_data(cache_key) if cached_data logger.info("Cache-hit voor '#{cache_key}'") return cached_data else logger.info("Cache-miss voor '#{cache_key}', data ophalen van API") begin data = fetch_users set_cache(cache_key, data) return data rescue => e logger.error("Fout bij ophalen API: #{e.message}") return nil end end end # Voorbeeld gebruik resultaat = main(logger) if resultaat puts "Gevonden gegevens: #{resultaat}" else puts "Geen gegevens beschikbaar." end ``` **Wat doet dit script?** - Het gebruikt een hash `@cache` om gegevens op te slaan met een timestamp. - Bij elke aanvraag controleert het of er een geldige cache bestaat binnen de TTL (hier 5 minuten). - Als er een cache-hit is, wordt dat gelogd en de data direct geretourneerd. - Bij een cache-miss wordt de API opgeroepen, de data wordt opgeslagen en geretourneerd. - Fouten tijdens API-aanroepen worden gelogd en het script geeft aan dat er geen gegevens beschikbaar zijn. **Noot:** - Voor productiegebruik zou je kunnen overwegen om een meer robuuste cache-oplossing te gebruiken (bijvoorbeeld op bestand of Redis). - Voor eenvoudige doeleinden is deze in-memory cache voldoende.

Hier is een Ruby-script dat een in-memory caching-mechanisme implementeert voor het opgegeven API-eindpunt: ```ruby require 'net/http' require 'json' require 'logger' class APICache def initialize(ttl: 300) @cache = {} @ttl = ttl # Time To Live in seconden @logger = Logger.new(STDOUT) @logger.level = Logger::INFO @logger.formatter = proc do |severity, datetime, progname, msg| "#{datetime.strftime('%Y-%m-%d %H:%M:%S')} [#{severity}] #{msg}\n" end end def fetch(endpoint) cache_key = endpoint if cached?(cache_key) @logger.info("CACHE HIT: #{endpoint}") return @cache[cache_key][:data] end @logger.info("CACHE MISS: #{endpoint}") data = fetch_from_api(endpoint) @cache[cache_key] = { data: data, timestamp: Time.now } data end def clear_expired expired_keys = @cache.select do |key, value| Time.now - value[:timestamp] > @ttl end.keys expired_keys.each do |key| @logger.info("Cache verlopen: #{key}") @cache.delete(key) end end def clear_all @cache.clear @logger.info("Complete cache geleegd") end def stats { total_entries: @cache.size, expired_entries: @cache.count { |k, v| Time.now - v[:timestamp] > @ttl } } end private def cached?(key) return false unless @cache.key?(key) if Time.now - @cache[key][:timestamp] > @ttl @cache.delete(key) return false end true end def fetch_from_api(endpoint) uri = URI(endpoint) response = Net::HTTP.get_response(uri) unless response.is_a?(Net::HTTPSuccess) raise "API request failed: #{response.code} #{response.message}" end JSON.parse(response.body) rescue => e @logger.error("API fout: #{e.message}") raise end end # Gebruiksvoorbeeld if __FILE__ == $0 # Maak cache aan met TTL van 5 minuten (300 seconden) cache = APICache.new(ttl: 300) # API endpoint api_endpoint = "https://api.example.com/users" begin # Haal data op (gebruikt cache indien beschikbaar) users_data = cache.fetch(api_endpoint) puts "Aantal gebruikers: #{users_data.length}" if users_data.is_a?(Array) # Toon cache statistieken stats = cache.stats puts "Cache statistieken: #{stats}" # Verwijder verlopen cache entries cache.clear_expired rescue => e puts "Fout: #{e.message}" end end ``` **Belangrijke kenmerken van dit script:** 1. **In-Memory Caching**: Data wordt opgeslagen in een Hash (`@cache`) in het geheugen 2. **TTL (Time To Live)**: Standaard 5 minuten, aanpasbaar via de constructor 3. **Cache Validatie**: Automatische verwijdering van verlopen entries 4. **Logging**: Duidelijke logging van cache hits en misses 5. **Foutafhandeling**: Robuuste error handling voor API requests 6. **Cache Beheer**: Methodes om cache te beheren en statistieken te tonen **Gebruik:** ```ruby # Cache aanmaken cache = APICache.new(ttl: 600) # 10 minuten TTL # Data ophalen (gebruikt cache indien beschikbaar) data = cache.fetch("https://api.example.com/users") # Cache beheren cache.clear_expired # Verwijder verlopen entries cache.clear_all # Leeg complete cache stats = cache.stats # Toon statistieken ``` **Logging output voorbeeld:** ``` 2024-01-15 10:30:45 [INFO] CACHE MISS: https://api.example.com/users 2024-01-15 10:31:10 [INFO] CACHE HIT: https://api.example.com/users 2024-01-15 10:35:45 [INFO] Cache verlopen: https://api.example.com/users ``` Dit script verbetert de prestaties aanzienlijk door API-requests te minimaliseren en biedt transparantie via uitgebreide logging.