Memorizzare le risorse nella Cache e condividerle tra un'esecuzione e l'altra

Un servizio tra quelli offerti da Google Apps Script che può tornare molto utile in determinate situazioni è Cache Service. La classe Cache, l'unica in esso presente, consente di inserire, recuperare e rimuovere elementi da una cache (ovvero una parte di memoria in cui un computer immagazzina le informazioni, più frequentemente usate, in modo da leggerle più velocemente in caso di riutilizzo successivo).

Questo tipo di funzionalità si può pertanto rilevare utile quando si lavora con frequenti accessi a sorgenti di dati esterne che possono, spesso e volentieri, essere lente nella risposta impiegando anche decine di secondi e, sia per una questione di ottimizzazione delle prestazioni nel fornire una risposta più immediata lato client, sia per evitare di superare i limiti di quota di esecuzione degli script (che portano al blocco del running mostrando il seguente errore: 'Exceeded maximum execution time') si ha la necessità di accelerare l'accesso alle risorse desiderate.

Il codice nell'esempio seguente interroga un'API esterna (mi sono avvalso di un servizio web chiamato JSONplaceholder il quale mette a disposizione alcune REST API fittizie da interrogare a scopo di test e prototipazione) che risponde un JSON costituito da 100 elementi (qui il JSON di esempio) e mostra nel file di log il primo elemento (con indice '0'), il numero totale degli elementi ed il tempo di esecuzione dello script.
La cosa particolare del codice è ovviamente un'altra ossia, alla prima esecuzione dello script viene interrogata l'API esterna per il recupero delle informazioni, mentre eseguendo nuovamente e successivamente lo script i dati vengono letti da Apps Script dalla cache. Questo avviene perchè tramite il metodo put di CacheService salviamo il risultato dell'interrogazione all'API nella cache, il quale, rimanendovi memorizzato temporaneamente (per il tempo di persistenza della cache che è stato indicato), può essere recuperato all'esecuzione successiva (sempre nei limiti di tempo, noti o definiti, della cache) tramite il metodo get:

function getJsonTest() {
  var cache = CacheService.getScriptCache();
  var cached = cache.get("cached-json-response");
  if (cached != null) {
    cached = JSON.parse(cached);
    Logger.log('Contenuto recuperato dalla cache');
    return cached;
  }
  var url = 'http://jsonplaceholder.typicode.com/posts/';
  var content = UrlFetchApp.fetch(url);
  cache.put("cached-json-response", content, 600);
  content = JSON.parse(content.getContentText());
  Logger.log('Contenuto recuperato dalla sorgente principale');
  return content;
}

function startFunction() {
  var start, stop, response;
  start = new Date().getTime();
  response = getJsonTest();
  stop = new Date().getTime();

  Logger.log(response[0]);
  Logger.log(response.length);
  Logger.log('Tempo di esecuzione: ' + (stop - start) + ' ms');
}

Esplorando il codice e definendo startFunction()  come la funzione di partenza, è possibile riassumerne i passaggi in modo semplice, ovvero quello che effettua è un controllo in prima istanza della presenza del contenuto desiderato salvato in cache tramite il metodo get (con il nome personalizzato "cached-json-response"), se lo trova lo restituisce alla funzione e prosegue con le operazioni (nell'esempio ci sono solo log) altrimenti prosegue con l'interrogazione all'API per restituire il dato recuperato previo salvataggio dello stesso in cache tramite il metodo put (definendone il nome "cached-json-response" e la durata di persistenza, nel caso specifico 600 secondi) in modo da poterlo recuperare da lì alla successiva esecuzione del codice (entro i 10 minuti definiti).

Tornando al tema delle prestazioni riporto di seguito i log della prima esecuzione (Fig. 1), ovvero quella dove viene interrogato il servizio esterno per il recupero dei dati, e della seconda (Fig. 2), ovvero quella dove viene recuperato dalla cache lo stesso contenuto salvato nella prima esecuzione:

Fig. 1 - File di log con il tempo di esecuzione per il recupero informazioni da un servizio web esterno

Fig. 2 - File di log con il tempo di esecuzione per il recupero informazioni dalla cache

Ovviamente essendo la sorgente originale dei dati un servizio di test che risponde un semplice JSON, il tempo necessario per interrogarla è decisamente irrisorio, niente a che vedere con chiamate REST API che impiegano 20 o 25 secondi per soddisfare la richiesta, tuttavia è evidente che, se pur parlando di numeri piccoli in valore assoluto, la modalità di recupero informazioni tramite l'accesso alla cache risulta (nel caso specifico) 10 volte più veloce rispetto all'accesso diretto al servizio.

Qualora ne aveste bisogno, potete fare riferimento alla documentazione ufficiale per la consultazione degli altri metodi della classe Cache del servizio CacheService.